> ## 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 definir el comportamiento de las organizaciones en las aplicaciones para la función Organizaciones de Auth0.

# Definir el comportamiento de la organización

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

Al configurar su aplicación en Auth0, puede especificar qué tipos de usuarios debe admitir. Algunas aplicaciones permiten que las personas inicien sesión con cuentas personales, mientras que otras están pensadas para miembros de [organizaciones](/es/docs/manage-users/organizations/organizations-overview). Algunas deben admitir ambos casos. Esto se conoce como comportamiento de organización y puede configurarse para cada aplicación que conecte a Auth0.

Por ejemplo, su aplicación podría tener:

* Una landing page de marketing genérica con un botón de **Iniciar sesión** que lleve a sus usuarios al flujo de inicio de sesión de Auth0 sin una Organización.
* Una URL independiente para cada uno de sus clientes B2B (por ejemplo, los usuarios de Acme van a `acme.yourcompany.com`) que redirija a los usuarios a Auth0 con una Organización, para que vean el botón de Login de <Tooltip tip="Single Sign-On (SSO): Servicio que, después de que un usuario inicia sesión en una aplicación, inicia automáticamente la sesión de ese usuario en otras aplicaciones." cta="Ver glosario" href="/es/docs/glossary?term=SSO">SSO</Tooltip> de Acme.

Puede definir el comportamiento de organización para admitir cualquiera de estos escenarios. Además, puede configurar el comportamiento de organización de modo que, si su aplicación requiere que se proporcione una Organización pero su usuario llega por error a Auth0 sin una organización, vea una pantalla en la que pueda introducir el nombre de su organización.

Puede definir el comportamiento de organización mediante el <Tooltip tip="Management API: Un producto que permite a los clientes realizar tareas administrativas." cta="Ver glosario" href="/es/docs/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip> o la <Tooltip tip="Auth0 Dashboard: El principal producto de Auth0 para configurar sus servicios." cta="Ver glosario" href="/es/docs/glossary?term=Management+API">Management API</Tooltip>.

<div id="auth0-dashboard">
  ## Auth0 Dashboard
</div>

Para definir el comportamiento de la organización desde Auth0 Dashboard:

1. Vaya a [Auth0 Dashboard > Applications](https://manage.auth0.com/#/applications) y seleccione la aplicación para la que desea configurar las organizaciones.
2. Cambie a la vista Login Experience y configure los ajustes correspondientes:

| Campo                         | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Asignación de API                                                                                                                                                                                                                                                                    |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Tipo de usuarios**          | Determina qué categoría de usuarios puede iniciar sesión en su aplicación.<br /><br />Las opciones incluyen: <ul> <li> **Usuarios individuales**: Los usuarios pueden registrarse con una cuenta personal e iniciar sesión directamente en su aplicación. Los usuarios individuales no pueden iniciar sesión con una Organización. </li> <li> **Usuarios empresariales**: Los usuarios deben ser miembros de una Organización para poder iniciar sesión. Cuando se selecciona esta opción, debe proporcionar una Organización al redirigir a los usuarios al endpoint `/authorize` o configurar su Login Flow para solicitar la Organización. </li> <li> **Ambos**: Los usuarios pueden iniciar sesión como miembros de una Organización o registrarse con una cuenta personal. </li> </ul>                                                                                        | **Tipo de usuarios** se asigna a `organization_usage`<br /><br />Opciones: <ul> <li>**Usuarios individuales** se asigna a `deny`</li> <li>**Usuarios empresariales** se asigna a `require`</li> <li>**Ambos** se asigna a `allow`</li> </ul>                                         |
| **Login Flow**                | Determina la pantalla de inicio de sesión inicial que se presenta a los usuarios cuando acceden a su aplicación. Solo puede configurar este campo si Tipo de usuarios está establecido en Usuarios empresariales o Ambos.<br /><br />Las opciones incluyen: <ul> <li> **Solicitar credenciales**: Primero se pide a los usuarios que proporcionen sus credenciales de inicio de sesión. Después de iniciar sesión, pueden seleccionar su Organización. </li> <li> **Solicitar Organización**: Primero se pide a los usuarios que seleccionen su Organización. Después, pueden proporcionar sus credenciales para iniciar sesión. </li> <li> **Sin solicitud**: Auth0 no determina qué pantalla de inicio de sesión se muestra a los usuarios. En su lugar, su aplicación es responsable de enviar a Auth0 los parámetros necesarios para mostrar la pantalla adecuada. </li> </ul> | **Login Flow** se asigna a `organization_require_behavior`<br /><br />Opciones: <ul> <li>**Solicitar credenciales** se asigna a `post_login_prompt`</li> <li>**Solicitar Organización** se asigna a `pre_login_prompt`</li> <li>**Sin solicitud** se asigna a `no_prompt`</li> </ul> |
| **Detección de organización** | Define el método utilizado para identificar la organización del usuario antes de la autenticación. Solo está disponible con el Login Flow Solicitar Organización.<br /><br />Las opciones incluyen: <ul> <li> **Solicitar correo electrónico de la organización**: Primero se pide a los usuarios que proporcionen la dirección de correo electrónico asociada a su Organización. </li> <li> **Solicitar nombre de la organización**: Primero se pide a los usuarios que proporcionen el nombre de su Organización. </li> <li> **Solicitar correo electrónico y nombre de la organización**: Primero se pide a los usuarios que proporcionen el nombre de su Organización o el correo electrónico asociado a su Organización. </li> </ul>                                                                                                                                          | <ul> <li> **Solicitar correos electrónicos**: se asigna a `email`. </li> <li> **Solicitar Organización**: se asigna a `organization_name`. </li> <li> **Solicitar correo electrónico y nombre de la organización**: se asigna a `email` y `organization_name`. </li> </ul>           |

3. Seleccione **Guardar cambios**.

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

Haga una llamada `PATCH` al [endpoint Update a Client](https://auth0.com/docs/api/management/v2#!/Clients/patch_clients_by_id). Asegúrese de sustituir los valores de marcador de posición `client_id`, `mgmt_api_access_token`, `organization_usage` y `organization_require_behavior` por su <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+ID">ID de cliente</Tooltip>, el <Tooltip tip="ID de cliente: valor de identificación proporcionado por Auth0 a su recurso registrado." cta="Ver glosario" href="/es/docs/glossary?term=Access+Token">Token de acceso</Tooltip> de la Management API, la opción de uso de la organización y la opción de comportamiento de la organización, respectivamente.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/clients/CLIENT_ID' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'cache-control: no-cache' \
    --header 'content-type: application/json' \
    --data '{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/clients/CLIENT_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", "{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }", 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/clients/CLIENT_ID"

  	payload := strings.NewReader("{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }")

  	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/clients/CLIENT_ID")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .header("cache-control", "no-cache")
    .body("{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }")
    .asString();
  ```

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

  var options = {
    method: 'PATCH',
    url: 'https://{yourDomain}/api/v2/clients/CLIENT_ID',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN',
      'cache-control': 'no-cache'
    },
    data: {
      organization_usage: 'ORG_USAGE',
      organization_require_behavior: 'ORG_REQUIRE_BEHAVIOR'
    }
  };

  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/clients/CLIENT_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 => "{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }",
    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 = "{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }"

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

  conn.request("PATCH", "/{yourDomain}/api/v2/clients/CLIENT_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/clients/CLIENT_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 = "{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }"

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

| Valor                            | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `CLIENT_ID`                      | ID de la aplicación a la que desea agregar comportamiento de organización.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `MGMT_API_ACCESS_TOKEN`          | [Tokens de acceso para la Management API](/es/docs/secure/tokens/access-tokens/management-api-access-tokens) con el scope `update:clients`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `ORGANIZATION_USAGE`             | Determina si su aplicación puede admitir que los usuarios inicien sesión en una organización. Las opciones incluyen: <ul> <li>`deny`: (Predeterminado) Los usuarios no pueden iniciar sesión mediante una organización.</li> <li>`allow`: Los usuarios pueden iniciar sesión con o sin una Organización. Cuando se selecciona esta opción, debe proporcionar una organización al redirigir a los usuarios al endpoint `/authorize`.</li> <li>`require`: Los usuarios deben iniciar sesión mediante una organización. Cuando se selecciona esta opción, debe proporcionar una organización al redirigir a los usuarios al endpoint `/authorize` o establecer `organization_require_behavior` en `pre_login_prompt` para permitir que los usuarios elijan una organización antes de iniciar sesión.</li> </ul> |
| `ORGANIZATION_REQUIRE_BEHAVIOR`  | Determina el Login Flow que se presenta a los usuarios que acceden a su aplicación. Solo se aplica cuando `organization_usage` se establece en `require` o `allow`.<br /><br />Las opciones incluyen: <ul> <li>`no_prompt`: (Predeterminado) No se muestra ninguna pantalla. Se rechazan las solicitudes sin un parámetro de organización válido.</li> <li>`pre_login_prompt`: Se solicita a los usuarios que seleccionen una Organización antes de poder iniciar sesión. Solo puede usar esta opción si `organization_usage` se establece en `require`.</li> <li>`post_login_prompt`: Se solicita a los usuarios que inicien sesión con sus credenciales. Después de iniciar sesión, se les solicita que seleccionen su Organización.</li> </ul>                                                            |
| `ORGANIZATION_DISCOVERY_METHODS` | Determina el método para identificar la organización de un usuario antes de la autenticación. Solo se aplica cuando `organization_require_behavior` es `pre_login_prompt` y `organization_usage` se establece en require o allow. <ul> <li> `email`: (Predeterminado) Se solicita a los usuarios que introduzcan la dirección de correo electrónico asociada a su Organización. </li> <li> `organization_name`: Se solicita a los usuarios que introduzcan el nombre asociado a su Organización. </li> <li> `Nombre de la organización` y `email`: Se solicita a los usuarios la dirección de correo electrónico o el nombre asociado a su Organización. </li> </ul>                                                                                                                                         |

<div id="response-status-codes">
  ### Códigos de estado de la respuesta
</div>

Los posibles códigos de estado de la respuesta son los siguientes:

| Código de estado | Código de error           | Message                                                                                                                                                  | Causa                                                                                                      |
| ---------------- | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| `200`            |                           | Cliente actualizado correctamente.                                                                                                                       |                                                                                                            |
| `400`            | `invalid_uri`             | URI de solicitud no válida. El mensaje variará según la causa.                                                                                           | La ruta no es válida.                                                                                      |
| `400`            | `invalid_body`            | Cuerpo de la solicitud no válido. El mensaje variará según la causa.                                                                                     | La carga útil de la solicitud no es válida.                                                                |
| `401`            |                           | Token inválido.                                                                                                                                          |                                                                                                            |
| `401`            |                           | El cliente no es global.                                                                                                                                 |                                                                                                            |
| `401`            |                           | Se recibió una firma no válida para la validación del JSON Web Token.                                                                                    |                                                                                                            |
| `403`            | `insufficient_scope`      | scope insuficiente; se esperaba alguno de los siguientes: `update:clients`.                                                                              | Se intentó leer o escribir un campo que no está permitido con los alcances del Bearer Token proporcionado. |
| `403`            | `insufficient_scope`      | Algunos campos no se pueden actualizar con los permisos otorgados por los alcances del Bearer Token. El mensaje variará según los campos y los alcances. | Se intentó leer o escribir un campo que no está permitido con los alcances del Bearer Token proporcionado. |
| `403`            | `operation_not_supported` | La cuenta no tiene permiso para realizar esta operación.                                                                                                 | La cuenta no tiene permiso para realizar esta operación.                                                   |
| `404`            | `inexistent_client`       | Cliente no encontrado.                                                                                                                                   | Recurso inexistente. La aplicación especificada no existe.                                                 |
| `429`            |                           | Demasiadas solicitudes. Revise los encabezados X-RateLimit-Limit, X-RateLimit-Remaining y X-RateLimit-Reset.                                             |                                                                                                            |