Lista de Documentos

En Esta Página

Llamadas API

Realizar llamadas API a ProcessMind

Esta guía te da ejemplos y buenas prácticas para usar la API de ProcessMind. Ya sea para consultar data, enviar información o automatizar workflows, es clave saber cómo interactuar con nuestra API.

Variables de autenticación

apiKey Para todas las solicitudes de API, debes incluir tu API key en los headers de la solicitud para autenticación. Puedes obtener tu API key en la configuración de tu cuenta en ProcessMind.
tenantId Algunos endpoints de la API requieren un Tenant ID para indicar el contexto de la solicitud. Este ID es único para tu organización y también se encuentra en la configuración de la cuenta.
datatableId Al trabajar con datasets, debes indicar el Datatable ID para identificar con qué datatable interactúas. Este ID está disponible en el menú de configuración del dataset, apartado [Get Data Table ID] dentro de ProcessMind.

Carga directa de archivos

ProcessMind permite subir archivos directamente a datatables usando URLs prefirmadas. Este método te permite cargar archivos de forma segura sin exponer tu API key ni información sensible. Recuerda que las URLs prefirmadas tienen tiempo limitado y se deben usar pronto tras obtenerlas. Para acceder a la URL de carga directa haz una petición GET al endpoint. Puedes obtener la URL desde el menú de configuración del dataset en [Get upload URL] dentro de ProcessMind. Puedes definir el tiempo máximo en 1 hora, 1 semana o 1 mes.

Resumen de endpoints

Método	Endpoint	Descripción
GET	`/tenant/{tenantId}/datatable/{datatableId}/uploads/presignedurl`	Devuelve una URL temporal pre‑firmada para subir un archivo a un datatable.
GET	`/tenant/{tenantId}/datasets`	Devuelve una lista de datasets del tenant indicado.
GET	`/tenant/{tenantId}`	Devuelve detalles sobre el tenant especificado.
GET	`/tenant/{tenantId}/organization`	Devuelve información de la organización del tenant.

Base URL

Todas las solicitudes a la API deben hacerse a la siguiente URL base: https://api.processmind.com

Obtener una URL de subida pre‑firmada

Endpoint: GET /tenant/{tenantId}/datatable/{datatableId}/uploads/presignedurl Parámetros:

tenantId – ID del tenant (string).
datatableId – ID del datatable al que deseas subir (string).
apiKey – Tu API key (string).

Devuelve: Un objeto de respuesta con PreSignedUploadUrl, una URL temporal que puedes usar para subir un archivo directamente (normalmente con HTTP PUT).

Ejemplo (utilizando el helper):

const presignedUrl = await getPresignedUploadUrl({
  apiKey,
  tenantId: 'tenant-123',
  datatableId: 'table-456'
});
console.log(presignedUrl); // ej: https://s3.amazonaws.com/…?X-Amz-Signature=…

Listar datasets

Endpoint: GET /tenant/{tenantId}/datasets Parámetros:

tenantId – ID del tenant.
apiKey – Tu API key.

Devuelve: Un array de objetos dataset que pertenecen al tenant.

Ejemplo:

const datasets = await getDatasets({
  apiKey,
  tenantId: 'tenant-123'
});
console.log(datasets);

Obtener información del tenant

Endpoint: GET /tenant/{tenantId} Parámetros:

tenantId – ID del tenant.
apiKey – Tu API key.

Devuelve: Un objeto con los metadatos del tenant, como nombre, fecha de creación y tipo de plan.

Ejemplo:

const tenantInfo = await getTenant({
  apiKey,
  tenantId: 'tenant-123'
});
console.log(tenantInfo);

Consultar detalles de la organización

Endpoint: GET /tenant/{tenantId}/organization Parámetros:

tenantId – ID del tenant.
apiKey – Tu API key.

Devuelve: Información sobre la organización asociada al tenant (por ejemplo: nombre de la empresa, dirección, datos de contacto).

Ejemplo:

const org = await getOrganization({
  apiKey,
  tenantId: 'tenant-123'
});
console.log(org);

Subir un archivo

La función uploadFile muestra cómo subir un archivo usando la URL pre‑firmada. El flujo general es:

Obtener la URL pre‑firmada usando getPresignedUploadUrl.
Hacer una petición PUT a esa URL con el archivo. La URL pre‑firmada autoriza la subida directa al proveedor de almacenamiento, por lo que no necesitas más credenciales.
(Opcional) Notificar a tu API que la subida finalizó, si tu backend lo requiere.

Aquí tienes un ejemplo simplificado usando fetch:

async function uploadFile({ apiKey, tenantId, datatableId, file }) {
  // Paso 1: Obtener la URL pre-firmada
  const uploadUrl = await getPresignedUploadUrl({ apiKey, tenantId, datatableId });
  
  // Paso 2: Subir el archivo por PUT
  await fetch(uploadUrl, {
    method: 'PUT',
    headers: {
      'Content-Type': file.type
    },
    body: file
  });
  
  // Paso 3: Opcional, notificar a tu API que finalizó
  // (depende de tu backend)
}

info

Las URLs pre‑firmadas expiran tras cierto tiempo (normalmente minutos). Úsalas enseguida tras obtenerlas.
Si la subida falla (ejemplo: interrupción de red), solicita una nueva URL antes de reintentar.
Mantén tu apiKey segura y no la expongas en el cliente (por ejemplo, en un front‑end público).

Ejemplo BASH

Script Bash básico para subir un archivo a ProcessMind usando dos llamadas curl, con campos de muestra para todos los valores.

Descargar ejemplo BASH

#!/bin/bash
# Script Bash minimal para subir un archivo a ProcessMind usando dos llamadas curl, con placeholders para todos los valores

# Sustituye los siguientes placeholders por tus propios valores:
# <API_KEY>, <TENANT_ID>, <DATATABLE_ID>, <FILE_PATH>

curl -s -H "x-api-key: <API_KEY>" \
    "https://api.processmind.com/tenant/<TENANT_ID>/datatable/<DATATABLE_ID>/uploads/presignedurl" \
    | grep -oP '"PreSignedUploadUrl"\s*:\s*"\K[^"]+' \
    | xargs -I {} curl -s -X PUT --upload-file "<FILE_PATH>" "{}"

Ejemplo NodeJS

Sube un archivo CSV local a ProcessMind usando una presigned URL.

Pasos:

Solicita una presigned upload URL del API.
Lee el archivo local del disco.
Sube el archivo a la presigned URL por HTTP PUT.

Configuración:

Ingresa tu API key, tenantId, datatableId y filePath al llamar a uploadFileToProcessMind().
La URL base de la API es https://api.processmind.com

Descargar ejemplo NodeJS

/**
 * Sube un archivo CSV local a ProcessMind usando una presigned URL.
 *
 * Pasos:
 * 1. Solicita una presigned upload URL del API.
 * 2. Lee el archivo local del disco.
 * 3. Sube el archivo a la presigned URL por HTTP PUT.
 *
 * Configuración:
 * - Usa tu API key, tenantId, datatableId y filePath al llamar uploadFileToProcessMind().
 * - La URL base es https://api.processmind.com
 */

const fs = require("node:fs");

/**
 * Sube un archivo a un datatable de ProcessMind usando una presigned URL.
 * @param {string} apiKey - Tu API key para autenticación.
 * @param {string} tenantId - ID de tu tenant.
 * @param {string} datatableId - ID del datatable.
 * @param {string} filePath - Ruta del archivo a subir.
 */

async function getApi({path, apiKey, apiUrl = "https://api.processmind.com"}) {
	try {
        const response = await fetch(`${apiUrl}${path}`, {
            method: "GET",
            headers: {
                "x-api-key": apiKey
            }
        });
        const body = await response.json();
        if (!response.ok) {
            console.error(`Error loading from API: ${response.status}, ${response.statusText}: ${body.message}`);
            return;
        }
        return body;
    } catch (err) {
        console.error("Unexpected error:", err);
    }
}

async function getPresignedUploadUrl({apiKey, tenantId, datatableId, apiUrl = "https://api.processmind.com"}) {
	return (await getApi({apiKey, path: `/tenant/${tenantId}/datatable/${datatableId}/uploads/presignedurl`, apiUrl})).PreSignedUploadUrl;
}

async function getDatasets({apiKey, tenantId, apiUrl = "https://api.processmind.com"}) {
	return await getApi({apiKey, path: `/tenant/${tenantId}/datasets`, apiUrl});
}

async function getTenant({apiKey, tenantId, apiUrl = "https://api.processmind.com"}) {
	return await getApi({apiKey, path: `/tenant/${tenantId}`, apiUrl});
}

async function getOrganization({apiKey, tenantId, apiUrl = "https://api.processmind.com"}) {
	return await getApi({apiKey, path: `/tenant/${tenantId}/organization`, apiUrl});
}

async function uploadFile({apiKey, tenantId, datatableId, filePath, apiUrl = "https://api.processmind.com"}) {
    try {
        const uploadUrl = await getPresignedUploadUrl({apiKey, tenantId, datatableId, apiUrl});

		console.log("Uploading file...");
        fs.readFile(filePath, async (err, data) => {
            if (err) {
                console.error("Error reading file:", err);
                return;
            }
            try {
                const uploadRes = await fetch(uploadUrl, {
                    method: "PUT",
                    body: data
                });
                if (!uploadRes.ok) {
                    console.error("Upload failed:", uploadRes.status, uploadRes.statusText);
                } else {
                    console.log("File uploaded successfully.");
                }
            } catch (uploadErr) {
                console.error("Error uploading file:", uploadErr);
            }
        });
    } catch (err) {
        console.error("Unexpected error:", err);
    }
}

// Exporta la función para usar en otros módulos
module.exports = { 
	getPresignedUploadUrl,
	getDatasets,
	getTenant,
	getOrganization,
	uploadFile 
};

Ejemplo Python

Sube un archivo CSV local a una API remota usando una presigned URL.

Pasos:

Solicita una presigned upload URL desde la API.
Lee el archivo local desde disco.
Sube el archivo a la presigned URL usando HTTP PUT.

Configuración:

Actualiza api_key, tenant_id, datatable_id y file_path según corresponda.

Descargar ejemplo Python

"""
Sube un archivo CSV local a una API remota usando una presigned URL.

Pasos:
1. Solicita una presigned upload URL desde la API.
2. Lee el archivo local desde disco.
3. Sube el archivo a la presigned URL con HTTP PUT.

Configuración:
- Actualiza api_key, tenant_id, datatable_id y file_path según sea necesario.
"""

import requests

# === Configuration ===
api_key = ""  # API key para autenticación
tenant_id = ""  # Identificador Tenant
datatable_id = ""  # Identificador Datatable
file_path = ""  # Ruta al archivo a subir


print("Fetching upload URL...")
api_url = "https://api.processmind.com"  # URL base API
presign_url = f"{api_url}/tenant/{tenant_id}/datatable/{datatable_id}/uploads/presignedurl"
presign_res = requests.get(presign_url, headers={"x-api-key": api_key})
if not presign_res.ok:
	print(f"Error fetching upload URL: {presign_res.status_code}, {presign_res.reason}: {presign_res.text}")
	exit(1)

presign_body = presign_res.json()
upload_url = presign_body.get("PreSignedUploadUrl")
if not upload_url:
	print("No presigned upload URL returned.")
	exit(1)

print("Uploading file...")
with open(file_path, "rb") as f:
	upload_res = requests.put(upload_url, data=f)
if not upload_res.ok:
	print(f"Upload failed: {upload_res.status_code}, {upload_res.reason}")
else:
	print("File uploaded successfully.")

Documentación Relacionada

Gestión de API Keys

Administra tus API keys fácilmente e integra ProcessMind con tus aplicaciones de forma segura y eficiente.