Automatizando la creación de Listas de SharePoint con Power Automate

En muchos proyectos de Microsoft 365 y Power Platform, una necesidad frecuente es crear Listas de SharePoint de forma rápida, especialmente cuando trabajamos con soluciones que deben desplegar listas en distintos sitios o ambientes.

Aunque Power Automate cuenta con muchas acciones nativas para trabajar con SharePoint, no siempre existe una acción directa para crear listas completas con columnas personalizadas, validaciones, tipos de datos y columnas de búsqueda. Para estos escenarios, una alternativa potente es usar la acción Enviar una solicitud HTTP a SharePoint, que permite ejecutar consultas contra la API REST de SharePoint desde Power Automate.

El caso de uso

El flujo que quiero compartir permite crear listas de SharePoint a partir de una definición JSON.

La idea es simple:

1. El flujo recibe o define una URL de sitio de SharePoint.
2. Recibe o genera un JSON con la estructura de listas y columnas.
3. Valida si cada lista ya existe.
4. Si no existe, la crea usando la API REST de SharePoint.
5. Recorre las columnas de cada lista.
6. Valida si cada columna ya existe.
7. Si no existe, la crea según su tipo.
8. Agrega las columnas a la vista predeterminada.
9. Ajusta la columna nativa Title para que no sea obligatoria.

Este enfoque permite construir una especie de motor de aprovisionamiento de listas, reutilizable para diferentes proyectos.

¿Por qué usar REST API desde Power Automate?

La acción Enviar una solicitud HTTP a SharePoint es útil cuando necesitamos ejecutar operaciones avanzadas que no están disponibles como acciones estándar del conector de SharePoint.

En este flujo se aprovechan endpoints como:

_api/web/lists

para crear listas, y:

_api/web/lists/GetByTitle('NombreLista')/Fields

para consultar o crear columnas.

Microsoft documenta que SharePoint REST permite trabajar con listas mediante operaciones CRUD, incluyendo la creación de listas con una solicitud POST hacia _api/web/lists.

Fuente oficial: Trabajar con listas y elementos de lista mediante REST

Ejemplo de JSON de entrada

El flujo puede recibir un JSON externo o usar un JSON de ejemplo definido dentro del propio flujo.

[
  {
    "Tabla": {
      "Title": "EJEMPLOArea",
      "Description": "Lista de Areas"
    },
    "Columnas": [
      {
        "__metadata": {
          "type": "SP.FieldText"
        },
        "FieldTypeKind": 2,
        "Title": "Area",
        "Required": true,
        "Indexed": true,
        "EnforceUniqueValues": true
      }
    ]
  },
  {
    "Tabla": {
      "Title": "EJEMPLOTrabajador",
      "Description": "Lista de Trabajadores"
    },
    "Columnas": [
      {
        "__metadata": {
          "type": "SP.FieldText"
        },
        "FieldTypeKind": 2,
        "Title": "Nombres y Apellidos",
        "Required": true,
        "Indexed": true,
        "EnforceUniqueValues": true
      },
      {
        "__metadata": {
          "type": "SP.FieldNumber"
        },
        "FieldTypeKind": 9,
        "Title": "Edad",
        "Required": false,
        "MinimumValue": 0,
        "MaximumValue": 200
      },
      {
        "__metadata": {
          "type": "SP.FieldCurrency"
        },
        "FieldTypeKind": 10,
        "Title": "Sueldo",
        "Required": false,
        "MinimumValue": 0,
        "MaximumValue": 1000000
      },
      {
        "__metadata": {
          "type": "SP.FieldDateTime"
        },
        "FieldTypeKind": 4,
        "Title": "Fecha de Nacimiento",
        "Required": false,
        "DisplayFormat": 0
      },
      {
        "__metadata": {
          "type": "SP.FieldLookup"
        },
        "FieldTypeKind": 7,
        "Title": "Area",
        "Required": false,
        "LookupList": "EJEMPLOArea",
        "LookupField": "area"
      },
      {
        "__metadata": {
          "type": "SP.FieldChoice"
        },
        "FieldTypeKind": 6,
        "Title": "Estado",
        "Required": true,
        "Choices": {
          "results": [
            "Pendiente",
            "En proceso",
            "Activo"
          ]
        },
        "EditFormat": 1,
        "DefaultValue": "Pendiente"
      }
    ]
  }
]

Con esta estructura, el flujo puede crear dos listas:

• EJEMPLOArea
• EJEMPLOTrabajador

Y en la lista de trabajadores puede crear columnas de texto, número, moneda, fecha, búsqueda y opción.

Paso 1: Inicializar la URL del sitio

El flujo inicializa una variable llamada Sitio.

Si el usuario no envía una URL, se usa una URL por defecto. Si el usuario sí envía una URL en el trigger, el flujo trabaja con esa dirección.

@if(
  equals(triggerBody()?['text'], null),
  'https://contoso.sharepoint.com/sites/comercial',
  triggerBody()?['text']
)

Este patrón hace que el flujo sea flexible, porque puede ejecutarse contra diferentes sitios de SharePoint sin modificar manualmente cada acción.

Paso 2: Parsear el JSON de configuración

Luego, el flujo usa una acción Parse JSON para leer la estructura de listas y columnas.

El esquema esperado es un arreglo de objetos, donde cada objeto contiene:

• Tabla: información de la lista.
• Columnas: arreglo con las columnas a crear.

{
  "type": "array",
  "items": {
    "type": "object",
    "properties": {
      "Tabla": {
        "type": "object",
        "properties": {}
      },
      "Columnas": {
        "type": "array"
      }
    },
    "required": [
      "Tabla",
      "Columnas"
    ]
  }
}

Este diseño permite que el flujo sea parametrizable. En vez de construir una automatización distinta para cada lista, basta con cambiar el JSON.

Paso 3: Obtener las listas existentes

Antes de crear una lista, el flujo obtiene las listas existentes del sitio usando el conector de SharePoint.

Luego filtra el resultado para verificar si ya existe una lista con el mismo nombre:

@equals(item()?['DisplayName'], variables('Lista')?['Title'])

Si no existe, el flujo ejecuta una solicitud HTTP POST contra:

_api/web/lists

Ejemplo del cuerpo usado por el flujo:

{
  "__metadata": {
    "type": "SP.List"
  },
  "AllowContentTypes": true,
  "BaseTemplate": 100,
  "ContentTypesEnabled": true,
  "Description": "Lista de Trabajadores",
  "Title": "EJEMPLOTrabajador"
}

El valor BaseTemplate: 100 corresponde a una lista personalizada de SharePoint.

Paso 4: Crear columnas dinámicamente

Una vez creada o identificada la lista, el flujo obtiene sus columnas existentes:

_api/web/lists/GetByTitle('EJEMPLOTrabajador')/Fields

Después recorre cada columna definida en el JSON y valida si ya existe por su nombre interno.

Un detalle importante del flujo es que genera un nombre interno limpio para cada columna.

Por ejemplo:

Nombres y Apellidos

se convierte en:

nombresyapellidos

También elimina tildes, espacios, guiones, guiones bajos y caracteres como ñ.

Esto es clave porque en SharePoint el nombre interno de una columna puede quedar codificado si se crea directamente con espacios o caracteres especiales.

Paso 5: Crear columnas mediante JSON

Para columnas estándar como texto, número, moneda, fecha o elección, el flujo usa el endpoint:

_api/web/lists/getbytitle('NombreLista')/fields

Ejemplo conceptual:

{
  "__metadata": {
    "type": "SP.FieldText"
  },
  "FieldTypeKind": 2,
  "Title": "nombresyapellidos",
  "Required": true,
  "Indexed": true,
  "EnforceUniqueValues": true
}

Luego, el flujo actualiza el título visible de la columna para que el usuario final vea el nombre amigable:

{
  "__metadata": {
    "type": "SP.FieldText"
  },
  "Title": "Nombres y Apellidos"
}

Esto permite separar dos conceptos importantes:

• Nombre interno técnico: nombresyapellidos
• Nombre visible para el usuario: Nombres y Apellidos

Paso 6: Crear columnas Lookup mediante XML

Las columnas de búsqueda requieren un tratamiento especial, porque necesitan vincularse con otra lista.

En este flujo, cuando la columna es de tipo:

"SP.FieldLookup"

primero se obtiene el ID de la lista relacionada:

_api/web/lists/getbytitle('EJEMPLOArea')?$select=Id

Luego se crea la columna usando CreateFieldAsXml:

_api/web/lists/getbytitle('EJEMPLOTrabajador')/fields/createfieldasxml

Microsoft documenta que CreateFieldAsXml crea un campo a partir de los valores definidos en un parámetro de entrada basado en XML Schema.

Fuente oficial: CreateFieldAsXml

Ejemplo conceptual del XML:

<Field
  Type='Lookup'
  DisplayName='area'
  Name='area'
  List='{GUID_DE_LA_LISTA_AREA}'
  ShowField='area'
  Required='false' />

Este patrón es especialmente útil cuando queremos crear listas relacionadas automáticamente, por ejemplo:

• Área
• Trabajador
• Proyectos
• Clientes
• Solicitudes
• Categorías

Paso 7: Agregar columnas a la vista predeterminada

Después de crear cada columna, el flujo la agrega a la vista predeterminada de la lista:

_api/web/lists/GetByTitle('NombreLista')/DefaultView/ViewFields/AddViewField('nombreinterno')

Esto mejora la experiencia del usuario, porque las columnas aparecen automáticamente en la vista principal sin configuración manual adicional.

Paso 8: Ajustar la columna Title

Por defecto, las listas personalizadas de SharePoint incluyen la columna Title.

En muchos modelos de datos, esa columna no se necesita como campo obligatorio. Por eso, el flujo la actualiza para que no sea requerida:

{
  "__metadata": {
    "type": "SP.FieldText"
  },
  "Title": "Título",
  "Required": false
}

Luego la remueve de la vista predeterminada:

_api/web/lists/GetByTitle('NombreLista')/DefaultView/ViewFields/RemoveViewField('LinkTitle')

Esto permite que la lista quede más limpia y enfocada en las columnas realmente definidas por el modelo.

Buenas prácticas aplicadas en el flujo

¿Dónde puede usarse este patrón?

Este enfoque puede ser útil en escenarios como:

• Creación automática de listas para nuevos proyectos.
• Aprovisionamiento de ambientes de desarrollo, pruebas y producción.
• Despliegue de soluciones Power Platform.
• Generación de estructuras de datos para Power Apps.
• Migraciones o estandarización de sitios SharePoint.
• Plantillas corporativas reutilizables.

Conclusión

Este flujo convierte Power Automate en una herramienta de aprovisionamiento para SharePoint.

En vez de crear listas y columnas manualmente, podemos definir la estructura en JSON y dejar que Power Automate haga el trabajo usando SharePoint REST API.

El resultado es una solución más escalable, reutilizable y alineada con escenarios reales de automatización empresarial en Microsoft 365.

Si trabajas con Power Apps, Power Automate y SharePoint, este patrón puede ayudarte a estandarizar la creación de listas y acelerar el despliegue de soluciones.

Artículo técnico orientado a automatización de estructuras de SharePoint usando Power Automate, JSON y SharePoint REST API.