> ## Documentation Index
> Fetch the complete documentation index at: https://api-docs.rhombus.community/llms.txt
> Use this file to discover all available pages before exploring further.

# Control de acceso

> Administre el control de acceso de Rhombus a través de la API: liste puertas con control de acceso, desbloquee de forma remota, emita y asigne credenciales, cree grupos y concesiones de acceso, y active planes de confinamiento.

<Note>
  Esta página fue traducida automáticamente. Si encuentra errores o tiene sugerencias, [contáctenos](mailto:support@rhombus.com).
</Note>

## Descripción general

El control de acceso de Rhombus le permite administrar la entrada física en todas sus instalaciones desde una sola API. Las puertas con control de acceso están respaldadas por controladores de puerta y lectores de Rhombus, y cada desbloqueo, credencial y concesión está vinculado a la misma plataforma que registra las imágenes de sus cámaras, de modo que cada evento de entrada tiene contexto visual.

A través de la API, puede:

* **Listar puertas con control de acceso** e inspeccionar su configuración y estado en vivo
* **Desbloquear de forma remota** una puerta para una entrada momentánea
* **Emitir credenciales** (como tarjetas Wiegand) y asignarlas a usuarios
* **Crear grupos y concesiones de acceso** que vinculan usuarios, puertas y horarios
* **Activar planes de confinamiento** para asegurar una ubicación durante una emergencia

<Note>
  ¿Busca entrada táctil para visitantes? La guía [Control de acceso con código QR](/es/implementations/qr-code-access-control) (actualmente en beta) cubre la generación de códigos QR de duración limitada que una cámara de Rhombus lee para desbloquear una puerta. Esta guía cubre la superficie de control de acceso más amplia y de disponibilidad general.
</Note>

## Requisitos previos

<Note>
  Antes de comenzar, asegúrese de tener:

  * Una **clave de API de Rhombus** con permisos de control de acceso (generada en la Consola de Rhombus en Configuración > API)
  * Al menos una **puerta con control de acceso** configurada con un controlador de puerta y un lector de Rhombus
  * Los **UUID** de los usuarios, puertas y ubicaciones con los que planea trabajar (puede descubrir los UUID de las puertas con el endpoint de listado de puertas a continuación)
</Note>

Todas las solicitudes son `POST`, apuntan a la URL base `https://api2.rhombussystems.com` y requieren estos encabezados:

```bash theme={null}
x-auth-scheme: api-token
x-auth-apikey: YOUR_API_KEY
Content-Type: application/json
```

## Listar puertas con control de acceso

Recupere las puertas con control de acceso de su organización. La respuesta está paginada: envíe un cuerpo vacío para la primera página y luego envíe el `lastEvaluatedKey` devuelto en las solicitudes posteriores hasta que vuelva vacío.

<CodeGroup>
  ```python Python theme={null}
  import requests

  headers = {
      "x-auth-scheme": "api-token",
      "x-auth-apikey": "YOUR_API_KEY",
      "Content-Type": "application/json"
  }

  response = requests.post(
      "https://api2.rhombussystems.com/api/component/findAccessControlledDoors",
      headers=headers,
      json={
          "maxPageSize": 100
      }
  )

  data = response.json()
  for door in data.get("accessControlledDoors", []):
      print(f"{door['name']} ({door['uuid']}) - estado predeterminado: {door.get('defaultState')}")

  # Pagine si quedan más puertas
  next_key = data.get("lastEvaluatedKey")
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://api2.rhombussystems.com/api/component/findAccessControlledDoors', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-auth-scheme': 'api-token',
      'x-auth-apikey': 'YOUR_API_KEY'
    },
    body: JSON.stringify({
      maxPageSize: 100
    })
  });

  const data = await response.json();
  for (const door of data.accessControlledDoors || []) {
    console.log(`${door.name} (${door.uuid}) - estado predeterminado: ${door.defaultState}`);
  }

  const nextKey = data.lastEvaluatedKey;
  ```

  ```bash cURL theme={null}
  curl -X POST https://api2.rhombussystems.com/api/component/findAccessControlledDoors \
    -H "Content-Type: application/json" \
    -H "x-auth-scheme: api-token" \
    -H "x-auth-apikey: YOUR_API_KEY" \
    -d '{"maxPageSize": 100}'
  ```
</CodeGroup>

### Parámetros de solicitud

<ParamField path="maxPageSize" type="integer">
  Número máximo de puertas a devolver en una sola página.
</ParamField>

<ParamField path="lastEvaluatedKey" type="string">
  Cursor de paginación devuelto por una llamada anterior. Omítalo en la primera solicitud; proporciónelo para obtener la siguiente página.
</ParamField>

### Respuesta

<ResponseField name="accessControlledDoors" type="array">
  La lista de puertas con control de acceso. Campos clave por puerta:

  <Expandable title="campos de la puerta">
    <ResponseField name="uuid" type="string">
      Identificador único de la puerta. Use este valor donde se requiera un `accessControlledDoorUuid`.
    </ResponseField>

    <ResponseField name="name" type="string">
      Nombre visible de la puerta (por ejemplo, "Entrada principal").
    </ResponseField>

    <ResponseField name="locationUuid" type="string">
      La ubicación a la que pertenece la puerta.
    </ResponseField>

    <ResponseField name="defaultState" type="string">
      Modo de acceso de referencia, uno de `ACCESS_CONTROLLED` o `UNLOCKED`.
    </ResponseField>

    <ResponseField name="remoteUnlockEnabled" type="boolean">
      Si la puerta acepta solicitudes de desbloqueo remoto a través de la API.
    </ResponseField>

    <ResponseField name="unlockTimeSec" type="integer">
      Cuánto tiempo permanece desbloqueada la puerta tras un desbloqueo estándar, en segundos.
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="lastEvaluatedKey" type="string">
  Cursor de paginación. Cuando está presente, envíelo de nuevo en la siguiente solicitud para recuperar más puertas.
</ResponseField>

<Tip>
  Si solo necesita el estado ligero de la puerta en lugar de la configuración completa, use `/api/component/findMinimalStateAccessControlledDoors`, que devuelve cada puerta más una réplica de estado compacta.
</Tip>

## Desbloquear una puerta de forma remota

Active un desbloqueo momentáneo en una puerta con control de acceso. La puerta se vuelve a bloquear automáticamente después de su tiempo de desbloqueo configurado. El desbloqueo remoto solo funciona cuando `remoteUnlockEnabled` es `true` para la puerta de destino.

<CodeGroup>
  ```python Python theme={null}
  import requests

  headers = {
      "x-auth-scheme": "api-token",
      "x-auth-apikey": "YOUR_API_KEY",
      "Content-Type": "application/json"
  }

  response = requests.post(
      "https://api2.rhombussystems.com/api/accesscontrol/unlockAccessControlledDoor",
      headers=headers,
      json={
          "accessControlledDoorUuid": "YOUR_DOOR_UUID"
      }
  )

  result = response.json()
  print(result.get("type"))  # SUCCESS o ERROR
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://api2.rhombussystems.com/api/accesscontrol/unlockAccessControlledDoor', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-auth-scheme': 'api-token',
      'x-auth-apikey': 'YOUR_API_KEY'
    },
    body: JSON.stringify({
      accessControlledDoorUuid: 'YOUR_DOOR_UUID'
    })
  });

  const result = await response.json();
  console.log(result.type); // SUCCESS o ERROR
  ```

  ```bash cURL theme={null}
  curl -X POST https://api2.rhombussystems.com/api/accesscontrol/unlockAccessControlledDoor \
    -H "Content-Type: application/json" \
    -H "x-auth-scheme: api-token" \
    -H "x-auth-apikey: YOUR_API_KEY" \
    -d '{"accessControlledDoorUuid": "YOUR_DOOR_UUID"}'
  ```
</CodeGroup>

<ParamField path="accessControlledDoorUuid" type="string" required>
  El UUID de la puerta a desbloquear, del endpoint de listado de puertas.
</ParamField>

<ResponseField name="type" type="string">
  Resultado de la solicitud, ya sea `SUCCESS` o `ERROR`.
</ResponseField>

<Note>
  Cada desbloqueo remoto se registra como un evento de acceso con imágenes de las cámaras asociadas a la puerta, lo que le brinda un registro de auditoría completo.
</Note>

## Emitir y asignar una credencial

Las credenciales son las tarjetas o llaveros físicos que acepta un lector. Este ejemplo crea una credencial Wiegand y la asigna a un usuario. Rhombus admite varios formatos de credenciales: el endpoint `createWiegandCredential` toma un `wiegandFormat` y los campos relevantes para ese formato.

### Crear una credencial Wiegand

<CodeGroup>
  ```python Python theme={null}
  import requests
  import time

  headers = {
      "x-auth-scheme": "api-token",
      "x-auth-apikey": "YOUR_API_KEY",
      "Content-Type": "application/json"
  }

  now_sec = int(time.time())
  one_year_sec = 365 * 24 * 60 * 60

  response = requests.post(
      "https://api2.rhombussystems.com/api/accesscontrol/createWiegandCredential",
      headers=headers,
      json={
          "wiegandFormat": "H10301",
          "facilityCode": 42,
          "cardNumber": 10537,
          "userUuid": "YOUR_USER_UUID",
          "startDateEpochSecInclusive": now_sec,
          "endDateEpochSecExclusive": now_sec + one_year_sec
      }
  )

  credential = response.json().get("credential", {})
  print(f"Credencial creada {credential.get('uuid')} - estado {credential.get('workflowStatus')}")
  ```

  ```javascript JavaScript theme={null}
  const nowSec = Math.floor(Date.now() / 1000);
  const oneYearSec = 365 * 24 * 60 * 60;

  const response = await fetch('https://api2.rhombussystems.com/api/accesscontrol/createWiegandCredential', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-auth-scheme': 'api-token',
      'x-auth-apikey': 'YOUR_API_KEY'
    },
    body: JSON.stringify({
      wiegandFormat: 'H10301',
      facilityCode: 42,
      cardNumber: 10537,
      userUuid: 'YOUR_USER_UUID',
      startDateEpochSecInclusive: nowSec,
      endDateEpochSecExclusive: nowSec + oneYearSec
    })
  });

  const { credential } = await response.json();
  console.log(`Credencial creada ${credential.uuid} - estado ${credential.workflowStatus}`);
  ```

  ```bash cURL theme={null}
  curl -X POST https://api2.rhombussystems.com/api/accesscontrol/createWiegandCredential \
    -H "Content-Type: application/json" \
    -H "x-auth-scheme: api-token" \
    -H "x-auth-apikey: YOUR_API_KEY" \
    -d '{
      "wiegandFormat": "H10301",
      "facilityCode": 42,
      "cardNumber": 10537,
      "userUuid": "YOUR_USER_UUID",
      "startDateEpochSecInclusive": 1712620800,
      "endDateEpochSecExclusive": 1744156800
    }'
  ```
</CodeGroup>

<ParamField path="wiegandFormat" type="string" required>
  El formato de tarjeta Wiegand. Uno de `H10301`, `D10202`, `H10304`, `HID_CORP1000_STD_35`, `HID_CORP1000_STD_48`, `WIEGAND_64BIT_RAW` o `CUSTOM`. Los campos que complete dependen del formato: para el formato estándar de 26 bits `H10301`, proporcione `facilityCode` y `cardNumber`.
</ParamField>

<ParamField path="facilityCode" type="integer">
  Código de instalación (sitio) codificado en la tarjeta. Usado por formatos como `H10301`.
</ParamField>

<ParamField path="cardNumber" type="integer">
  Número de tarjeta codificado en la tarjeta.
</ParamField>

<ParamField path="siteCode" type="integer">
  Código de sitio, usado por formatos que lo codifican por separado del código de instalación.
</ParamField>

<ParamField path="companyId" type="integer">
  ID de empresa, usado por los formatos HID Corporate 1000.
</ParamField>

<ParamField path="value" type="string">
  Valor de credencial sin procesar. Usado por los formatos `WIEGAND_64BIT_RAW` y `CUSTOM`.
</ParamField>

<ParamField path="userUuid" type="string">
  El usuario al que pertenece la credencial. Cuando se establece, la credencial se crea ya asignada a ese usuario.
</ParamField>

<ParamField path="startDateEpochSecInclusive" type="integer">
  Inicio de la ventana de validez de la credencial, en **segundos** epoch (inclusivo).
</ParamField>

<ParamField path="endDateEpochSecExclusive" type="integer">
  Fin de la ventana de validez de la credencial, en **segundos** epoch (exclusivo).
</ParamField>

<Warning>
  Las fechas de validez de la credencial se expresan en **segundos** epoch, no en milisegundos. La mayoría de los demás endpoints de Rhombus usan milisegundos epoch, así que convierta con cuidado.
</Warning>

La respuesta devuelve el objeto `credential` creado, incluyendo su `uuid`, `lowercaseHexValue` y `workflowStatus` (`ACTIVE`, `UNASSIGNED`, `SUSPENDED` o `REVOKED`).

### Asignar una credencial existente a un usuario

Si una credencial ya existe (por ejemplo, se creó sin asignar), asígnela a un usuario por su valor hexadecimal.

<CodeGroup>
  ```python Python theme={null}
  import requests

  headers = {
      "x-auth-scheme": "api-token",
      "x-auth-apikey": "YOUR_API_KEY",
      "Content-Type": "application/json"
  }

  response = requests.post(
      "https://api2.rhombussystems.com/api/accesscontrol/assignAccessControlCredential",
      headers=headers,
      json={
          "credentialHexValue": "002a2929",
          "userUuid": "YOUR_USER_UUID"
      }
  )
  print(response.json())
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://api2.rhombussystems.com/api/accesscontrol/assignAccessControlCredential', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-auth-scheme': 'api-token',
      'x-auth-apikey': 'YOUR_API_KEY'
    },
    body: JSON.stringify({
      credentialHexValue: '002a2929',
      userUuid: 'YOUR_USER_UUID'
    })
  });
  console.log(await response.json());
  ```

  ```bash cURL theme={null}
  curl -X POST https://api2.rhombussystems.com/api/accesscontrol/assignAccessControlCredential \
    -H "Content-Type: application/json" \
    -H "x-auth-scheme: api-token" \
    -H "x-auth-apikey: YOUR_API_KEY" \
    -d '{
      "credentialHexValue": "002a2929",
      "userUuid": "YOUR_USER_UUID"
    }'
  ```
</CodeGroup>

<ParamField path="credentialHexValue" type="string" required>
  El valor hexadecimal de la credencial a asignar.
</ParamField>

<ParamField path="userUuid" type="string" required>
  El usuario al que asignar la credencial.
</ParamField>

<Tip>
  Administre el ciclo de vida de una credencial con `/api/accesscontrol/suspendAccessControlCredential`, `/api/accesscontrol/unsuspendAccessControlCredential` y `/api/accesscontrol/revokeAccessControlCredential`. Para revisar las credenciales de un usuario, llame a `/api/accesscontrol/findAccessControlCredentialByUser` con su `userUuid`.
</Tip>

## Otorgar acceso con grupos y horarios

Rhombus modela "quién puede abrir qué puertas y cuándo" como una **concesión de acceso**. Una concesión vincula un conjunto de usuarios (directamente o a través de **grupos de acceso**) con un conjunto de puertas, opcionalmente restringido por un **horario**. El flujo típico es: crear un grupo, agregar usuarios y luego crear una concesión que vincule el grupo con puertas y un horario.

### Crear un grupo de acceso y agregar usuarios

<CodeGroup>
  ```python Python theme={null}
  import requests

  headers = {
      "x-auth-scheme": "api-token",
      "x-auth-apikey": "YOUR_API_KEY",
      "Content-Type": "application/json"
  }

  # Crear el grupo
  create = requests.post(
      "https://api2.rhombussystems.com/api/accesscontrol/createAccessControlGroup",
      headers=headers,
      json={
          "name": "Personal de almacén",
          "description": "Empleados con acceso permitido al almacén"
      }
  )
  group_uuid = create.json()["group"]["uuid"]

  # Agregar usuarios a él
  requests.post(
      "https://api2.rhombussystems.com/api/accesscontrol/addUsersToAccessControlGroup",
      headers=headers,
      json={
          "groupUuid": group_uuid,
          "userUuids": ["USER_UUID_1", "USER_UUID_2"]
      }
  )
  ```

  ```javascript JavaScript theme={null}
  const headers = {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  };

  // Crear el grupo
  const create = await fetch('https://api2.rhombussystems.com/api/accesscontrol/createAccessControlGroup', {
    method: 'POST',
    headers,
    body: JSON.stringify({
      name: 'Personal de almacén',
      description: 'Empleados con acceso permitido al almacén'
    })
  });
  const groupUuid = (await create.json()).group.uuid;

  // Agregar usuarios a él
  await fetch('https://api2.rhombussystems.com/api/accesscontrol/addUsersToAccessControlGroup', {
    method: 'POST',
    headers,
    body: JSON.stringify({
      groupUuid,
      userUuids: ['USER_UUID_1', 'USER_UUID_2']
    })
  });
  ```

  ```bash cURL theme={null}
  # 1. Crear el grupo
  curl -X POST https://api2.rhombussystems.com/api/accesscontrol/createAccessControlGroup \
    -H "Content-Type: application/json" \
    -H "x-auth-scheme: api-token" \
    -H "x-auth-apikey: YOUR_API_KEY" \
    -d '{"name": "Personal de almacén", "description": "Empleados con acceso permitido al almacén"}'

  # 2. Agregar usuarios (use el uuid del grupo de la respuesta anterior)
  curl -X POST https://api2.rhombussystems.com/api/accesscontrol/addUsersToAccessControlGroup \
    -H "Content-Type: application/json" \
    -H "x-auth-scheme: api-token" \
    -H "x-auth-apikey: YOUR_API_KEY" \
    -d '{"groupUuid": "GROUP_UUID", "userUuids": ["USER_UUID_1", "USER_UUID_2"]}'
  ```
</CodeGroup>

<ParamField path="name" type="string" required>
  Nombre del grupo de acceso.
</ParamField>

<ParamField path="description" type="string">
  Descripción opcional del grupo.
</ParamField>

<ParamField path="userUuids" type="array">
  Lista opcional de UUID de usuarios con los que inicializar el grupo al momento de la creación. También puede agregar miembros más tarde con `addUsersToAccessControlGroup`.
</ParamField>

### (Opcional) Crear un horario semanal

Para restringir una concesión a horas específicas, primero cree un horario y haga referencia a su UUID en la concesión. Los horarios semanales usan la estrategia `WEEKLY_REPEATING_MINUTES`.

<CodeGroup>
  ```python Python theme={null}
  import requests

  headers = {
      "x-auth-scheme": "api-token",
      "x-auth-apikey": "YOUR_API_KEY",
      "Content-Type": "application/json"
  }

  response = requests.post(
      "https://api2.rhombussystems.com/api/schedule/createWeeklySchedule",
      headers=headers,
      json={
          "schedule": {
              "name": "Horario laboral",
              "strategy": "WEEKLY_REPEATING_MINUTES"
          }
      }
  )
  schedule_uuid = response.json().get("scheduleUuid")
  print(schedule_uuid)
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://api2.rhombussystems.com/api/schedule/createWeeklySchedule', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-auth-scheme': 'api-token',
      'x-auth-apikey': 'YOUR_API_KEY'
    },
    body: JSON.stringify({
      schedule: {
        name: 'Horario laboral',
        strategy: 'WEEKLY_REPEATING_MINUTES'
      }
    })
  });
  const { scheduleUuid } = await response.json();
  console.log(scheduleUuid);
  ```

  ```bash cURL theme={null}
  curl -X POST https://api2.rhombussystems.com/api/schedule/createWeeklySchedule \
    -H "Content-Type: application/json" \
    -H "x-auth-scheme: api-token" \
    -H "x-auth-apikey: YOUR_API_KEY" \
    -d '{"schedule": {"name": "Horario laboral", "strategy": "WEEKLY_REPEATING_MINUTES"}}'
  ```
</CodeGroup>

La respuesta devuelve un `scheduleUuid`. Use `/api/schedule/getSchedules` y `/api/schedule/getScheduleDataV2` para revisar los horarios, y administre los intervalos de tiempo semanales detallados en la Consola de Rhombus.

### Crear la concesión de acceso

Vincule el grupo, las puertas y (opcionalmente) un horario. Use el modo `DEFAULT` para una concesión de acceso estándar.

<CodeGroup>
  ```python Python theme={null}
  import requests

  headers = {
      "x-auth-scheme": "api-token",
      "x-auth-apikey": "YOUR_API_KEY",
      "Content-Type": "application/json"
  }

  response = requests.post(
      "https://api2.rhombussystems.com/api/accesscontrol/createAccessGrant",
      headers=headers,
      json={
          "accessGrant": {
              "name": "Personal de almacén - Horario laboral",
              "locationUuid": "YOUR_LOCATION_UUID",
              "mode": "DEFAULT",
              "groupUuids": ["GROUP_UUID"],
              "accessControlledDoorUuids": ["DOOR_UUID_1", "DOOR_UUID_2"],
              "scheduleUuid": "SCHEDULE_UUID"
          }
      }
  )

  data = response.json()
  if data.get("error"):
      print("Error:", data.get("errorMsg"))
  else:
      print("Concesión creada:", data["accessGrant"]["uuid"])
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://api2.rhombussystems.com/api/accesscontrol/createAccessGrant', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-auth-scheme': 'api-token',
      'x-auth-apikey': 'YOUR_API_KEY'
    },
    body: JSON.stringify({
      accessGrant: {
        name: 'Personal de almacén - Horario laboral',
        locationUuid: 'YOUR_LOCATION_UUID',
        mode: 'DEFAULT',
        groupUuids: ['GROUP_UUID'],
        accessControlledDoorUuids: ['DOOR_UUID_1', 'DOOR_UUID_2'],
        scheduleUuid: 'SCHEDULE_UUID'
      }
    })
  });

  const data = await response.json();
  if (data.error) {
    console.error('Error:', data.errorMsg);
  } else {
    console.log('Concesión creada:', data.accessGrant.uuid);
  }
  ```

  ```bash cURL theme={null}
  curl -X POST https://api2.rhombussystems.com/api/accesscontrol/createAccessGrant \
    -H "Content-Type: application/json" \
    -H "x-auth-scheme: api-token" \
    -H "x-auth-apikey: YOUR_API_KEY" \
    -d '{
      "accessGrant": {
        "name": "Personal de almacén - Horario laboral",
        "locationUuid": "YOUR_LOCATION_UUID",
        "mode": "DEFAULT",
        "groupUuids": ["GROUP_UUID"],
        "accessControlledDoorUuids": ["DOOR_UUID_1", "DOOR_UUID_2"],
        "scheduleUuid": "SCHEDULE_UUID"
      }
    }'
  ```
</CodeGroup>

<ParamField path="accessGrant.name" type="string">
  Nombre legible para la concesión.
</ParamField>

<ParamField path="accessGrant.locationUuid" type="string">
  La ubicación a la que se aplica la concesión.
</ParamField>

<ParamField path="accessGrant.mode" type="string">
  Modo de concesión, uno de `DEFAULT` o `GUEST_PASS_INDIVIDUAL`. Use `DEFAULT` para el acceso estándar de empleados.
</ParamField>

<ParamField path="accessGrant.groupUuids" type="array">
  Grupos de acceso cuyos miembros reciben acceso. Combine con `userUuids` para otorgar acceso a usuarios individuales directamente.
</ParamField>

<ParamField path="accessGrant.userUuids" type="array">
  Usuarios individuales a los que otorgar acceso, además de cualquier grupo.
</ParamField>

<ParamField path="accessGrant.accessControlledDoorUuids" type="array">
  Las puertas que abre esta concesión. También puede apuntar a puertas por etiqueta con `doorLabelIds`.
</ParamField>

<ParamField path="accessGrant.scheduleUuid" type="string">
  Horario opcional que restringe cuándo está activa la concesión. Omítalo para acceso 24/7.
</ParamField>

<ResponseField name="accessGrant" type="object">
  La concesión creada, incluyendo su `uuid` generado.
</ResponseField>

<ResponseField name="error" type="boolean">
  `true` si la concesión no se pudo crear. Consulte `errorMsg` para más detalles y `warningMsg` para notas no fatales.
</ResponseField>

## Activar un plan de confinamiento

Los planes de confinamiento le permiten cambiar instantáneamente el estado de acceso de muchas puertas en una ubicación durante una emergencia. Primero liste los planes configurados para su organización y luego active uno o más para una ubicación.

### Buscar planes de confinamiento disponibles

<CodeGroup>
  ```python Python theme={null}
  import requests

  headers = {
      "x-auth-scheme": "api-token",
      "x-auth-apikey": "YOUR_API_KEY",
      "Content-Type": "application/json"
  }

  response = requests.post(
      "https://api2.rhombussystems.com/api/accesscontrol/lockdownPlan/findLockdownPlans",
      headers=headers,
      json={}
  )
  for plan in response.json().get("lockdownPlans", []):
      print(f"{plan.get('name')}: {plan.get('uuid')}")
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://api2.rhombussystems.com/api/accesscontrol/lockdownPlan/findLockdownPlans', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-auth-scheme': 'api-token',
      'x-auth-apikey': 'YOUR_API_KEY'
    },
    body: JSON.stringify({})
  });
  for (const plan of (await response.json()).lockdownPlans || []) {
    console.log(`${plan.name}: ${plan.uuid}`);
  }
  ```

  ```bash cURL theme={null}
  curl -X POST https://api2.rhombussystems.com/api/accesscontrol/lockdownPlan/findLockdownPlans \
    -H "Content-Type: application/json" \
    -H "x-auth-scheme: api-token" \
    -H "x-auth-apikey: YOUR_API_KEY" \
    -d '{}'
  ```
</CodeGroup>

### Activar el confinamiento para una ubicación

<CodeGroup>
  ```python Python theme={null}
  import requests
  import time

  headers = {
      "x-auth-scheme": "api-token",
      "x-auth-apikey": "YOUR_API_KEY",
      "Content-Type": "application/json"
  }

  response = requests.post(
      "https://api2.rhombussystems.com/api/accesscontrol/lockdownPlan/activateLockdownForLocation",
      headers=headers,
      json={
          "locationUuid": "YOUR_LOCATION_UUID",
          "lockdownPlanUuids": ["LOCKDOWN_PLAN_UUID"],
          "stateUpdatedAtMillis": int(time.time() * 1000)
      }
  )

  data = response.json()
  print("Resultado:", data.get("result"))
  print("Estado de la ubicación:", data.get("state", {}).get("state"))
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://api2.rhombussystems.com/api/accesscontrol/lockdownPlan/activateLockdownForLocation', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-auth-scheme': 'api-token',
      'x-auth-apikey': 'YOUR_API_KEY'
    },
    body: JSON.stringify({
      locationUuid: 'YOUR_LOCATION_UUID',
      lockdownPlanUuids: ['LOCKDOWN_PLAN_UUID'],
      stateUpdatedAtMillis: Date.now()
    })
  });

  const data = await response.json();
  console.log('Resultado:', data.result);
  console.log('Estado de la ubicación:', data.state?.state);
  ```

  ```bash cURL theme={null}
  curl -X POST https://api2.rhombussystems.com/api/accesscontrol/lockdownPlan/activateLockdownForLocation \
    -H "Content-Type: application/json" \
    -H "x-auth-scheme: api-token" \
    -H "x-auth-apikey: YOUR_API_KEY" \
    -d '{
      "locationUuid": "YOUR_LOCATION_UUID",
      "lockdownPlanUuids": ["LOCKDOWN_PLAN_UUID"],
      "stateUpdatedAtMillis": 1712707200000
    }'
  ```
</CodeGroup>

<ParamField path="locationUuid" type="string" required>
  La ubicación a poner en confinamiento.
</ParamField>

<ParamField path="lockdownPlanUuids" type="array" required>
  Los planes de confinamiento a activar. Use los UUID de `findLockdownPlans`.
</ParamField>

<ParamField path="stateUpdatedAtMillis" type="integer" required>
  La marca de tiempo actual del estado de confinamiento en milisegundos epoch, usada para concurrencia optimista. Envíe la hora actual al iniciar un confinamiento.
</ParamField>

<ResponseField name="result" type="string">
  Resultado de la activación, uno de `SUCCESS`, `INVALID_LOCKDOWN_PLANS` u `OPTIMISTIC_CONCURRENCY`.
</ResponseField>

<ResponseField name="state" type="object">
  El estado de confinamiento resultante de la ubicación, incluyendo `state` (`STANDARD_SECURITY` o `LOCKED_DOWN`) y la lista de `activeLockdownPlans`.
</ResponseField>

<Warning>
  Activar un confinamiento cambia el acceso físico en la ubicación de inmediato. Pruebe su integración con `/api/accesscontrol/lockdownPlan/enableLockdownTestModeForLocation` antes de usarla en producción, y finalice un confinamiento con `/api/accesscontrol/lockdownPlan/deactivateLockdownForLocation`.
</Warning>

## Casos de uso

<CardGroup cols={2}>
  <Card title="Entrada remota para visitantes" icon="bell-concierge">
    Permita que el software de recepción desbloquee una puerta bajo demanda cuando se verifica a un visitante, con imágenes de cámara adjuntas a cada desbloqueo.
  </Card>

  <Card title="Incorporación automatizada" icon="user-plus">
    Aprovisione la credencial y la membresía de grupo de un nuevo empleado desde su sistema de RR. HH. para que su acceso esté listo desde el primer día.
  </Card>

  <Card title="Ventanas de tiempo para contratistas" icon="user-clock">
    Emita credenciales con fechas explícitas de inicio y fin, y restrinja el acceso al horario laboral con un horario.
  </Card>

  <Card title="Confinamiento de emergencia" icon="shield-halved">
    Conecte un botón de pánico o un sistema de seguridad para activar un plan de confinamiento en toda una ubicación con una sola llamada a la API.
  </Card>
</CardGroup>

## Solución de problemas

<AccordionGroup>
  <Accordion title="El desbloqueo remoto devuelve ERROR">
    Confirme que la puerta tenga `remoteUnlockEnabled` establecido en `true` en la respuesta del listado de puertas, que el `accessControlledDoorUuid` sea correcto y que su clave de API tenga permisos de control de acceso. Las puertas que están fuera de línea no se pueden desbloquear de forma remota.
  </Accordion>

  <Accordion title="La credencial se crea pero se deniega el acceso">
    Crear y asignar una credencial no es suficiente por sí solo: el usuario también debe estar cubierto por una concesión de acceso que incluya la puerta de destino. Verifique que una concesión `DEFAULT` vincule al usuario (directamente o a través de un grupo) con la puerta, y que cualquier horario adjunto esté actualmente activo. Confirme también que el `workflowStatus` de la credencial sea `ACTIVE` y que la hora actual esté dentro de su ventana de inicio/fin.
  </Accordion>

  <Accordion title="Las fechas de validez de la credencial se comportan de forma inesperada">
    `startDateEpochSecInclusive` y `endDateEpochSecExclusive` usan **segundos** epoch, no milisegundos. Si una credencial expira de inmediato o nunca se activa, compruebe que no haya pasado un valor en milisegundos.
  </Accordion>

  <Accordion title="La activación del confinamiento devuelve OPTIMISTIC_CONCURRENCY">
    El estado de confinamiento de la ubicación cambió entre su lectura y su escritura. Vuelva a obtener el estado actual (por ejemplo, con `getOrCreateLocationLockdownState`) y luego reintente la activación con un `stateUpdatedAtMillis` actualizado.
  </Accordion>

  <Accordion title="La respuesta de la concesión de acceso tiene error establecido en true">
    Inspeccione `errorMsg` en la respuesta. Las causas comunes son hacer referencia a una puerta que no tiene una licencia de control de acceso disponible (consulte `unassignedACDLicensesDoorUuids` y `expiredACDLicensesDoorUuids` en la respuesta) o un `locationUuid` no válido.
  </Accordion>
</AccordionGroup>

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Control de acceso con código QR" icon="qrcode" href="/es/implementations/qr-code-access-control">
    Agregue entrada táctil con código QR autenticada por cámara para visitantes y eventos (beta).
  </Card>

  <Card title="Notificaciones por webhook" icon="webhook" href="/es/webhooks">
    Reciba eventos de acceso en tiempo real para que su aplicación pueda reaccionar en el momento en que se usa una puerta.
  </Card>

  <Card title="Referencia de la API" icon="code" href="/api-reference/overview">
    Explore los esquemas completos de solicitud y respuesta para cada endpoint de control de acceso.
  </Card>
</CardGroup>