Lista de documentos
Gestión de API Keys seguras Llamadas API
En esta página
> recursos > docs > api > llamadas api > Llamadas API

Llamadas API

Cómo hacer llamadas a la API de ProcessMind

Esta guía incluye ejemplos y buenas prácticas para llamadas a la API de ProcessMind. Ya sea para obtener data, enviar información o automatizar workflows, entender cómo interactuar con la API es clave. Para documentación, endpoints, autenticación, ejemplos y guías paso a paso, visita nuestra Documentación API en GitHub.

Variables de autenticación

  • apiKey Para todas las peticiones API, incluye tu API key en los headers para autenticación. Puedes obtenerla en los ajustes de tu cuenta ProcessMind.
  • tenantId Algunos endpoints requieren el Tenant ID para definir el contexto. Este ID es único para tu organización y se encuentra en la configuración de tu cuenta.
  • datatableId Al trabajar con datasets necesitas el Datatable ID para identificar a qué datatable accedes. Este ID está en el menú de configuración del dataset [Get Data Table ID] dentro de ProcessMind.

Subida directa de archivos

ProcessMind permite subir archivos directos a datatables usando URLs presigned. Este método sube tus archivos de forma segura sin exponer tu API key ni datos sensibles. Recuerda: las URLs presigned tienen tiempo limitado y deben usarse enseguida al recibirlas. Para obtener la URL de subida directa haz una petición GET al endpoint. Esta URL se encuentra en el menú de configuración del dataset [Get upload URL] dentro de ProcessMind. El tiempo se puede asignar: 1 hora, 1 semana o 1 mes máximo.

Resumen de Endpoints de la API

MétodoEndpointDescripción
GET/tenant/{tenantId}/datatable/{datatableId}/uploads/presignedurlDevuelve una URL temporal pre‑firmada para subir archivos a una datatable.
GET/tenant/{tenantId}/datasetsDevuelve una lista de datasets del tenant.
GET/tenant/{tenantId}Devuelve los detalles del tenant.
GET/tenant/{tenantId}/organizationDevuelve información sobre la organización del tenant.

API Base URL

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

Cómo obtener una URL de subida pre‑firmada

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

  • tenantId – ID del tenant (string).
  • datatableId – ID de la datatable donde subir el archivo (string).
  • apiKey – Tu API key (string).

Devuelve:
Objeto de respuesta con PreSignedUploadUrl, una URL temporal para subir el archivo directo (usualmente por HTTP PUT).

Ejemplo (usando el helper):

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

Cómo listar datasets

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

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

Devuelve:
Array de objetos dataset que pertenecen al tenant.

Ejemplo:

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

Cómo consultar detalles del tenant

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

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

Devuelve:
Objeto con meta datos del tenant: nombre, fecha de creación y plan.

Ejemplo:

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

Cómo consultar la organización

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

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

Devuelve:
Información de la organización asociada (ejemplo: nombre empresa, dirección, contacto).

Ejemplo:

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

Cómo subir un archivo

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

  1. Obtén la URL pre‑firmada con getPresignedUploadUrl.
  2. Haz un PUT a esa URL con el archivo. La URL autoriza la subida directa al storage, sin credenciales extra.
  3. (Opcional) Notifica a tu API que la subida terminó, si tu backend lo requiere.

Aquí tienes un ejemplo sencillo usando fetch para subir un archivo:

async function uploadFile({ apiKey, tenantId, datatableId, file }) {
	// Paso 1: Obtener URL pre‑firmada
	const uploadUrl = await getPresignedUploadUrl({ apiKey, tenantId, datatableId });
	
	// Paso 2: Subir archivo con PUT
	await fetch(uploadUrl, {
		method: "PUT",
		headers: {
			"Content-Type": file.type
		},
		body: file
	});
	
	// Paso 3: Notificar a tu API (opcional)
	// (Según tu backend)
}

info

  • Las URLs pre‑firmadas caducan en minutos. Úsalas justo después de obtenerlas.
  • Si la subida falla (ej: corte de red), pide una nueva URL pre‑firmada antes de reintentar.
  • Protege siempre tu apiKey y nunca la muestres en un frontend público.

Ejemplo Bash: Subida de un archivo

Script Bash sencillo para subir un archivo a ProcessMind con dos llamadas curl, usando datos a completar.

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 Node.js: Subida de archivo CSV local

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

Pasos:

  1. Solicita una URL presigned de subida a la API.
  2. Lee el archivo local.
  3. Sube el archivo con HTTP PUT.

Configuración:

  • Indica tu API key, tenantId, datatableId y filePath al llamar uploadFileToProcessMind().
  • La URL base de la API es https://api.processmind.com
Descargar ejemplo NodeJS
/**
 * Sube un archivo CSV local a ProcessMind usando una URL prefirmada.
 *
 * Pasos:
 * 1. Obtén una URL prefirmada del API para la subida.
 * 2. Lee el archivo local desde disco.
 * 3. Sube el archivo a la URL prefirmada usando HTTP PUT.
 *
 * Configuración:
 * - Indica tu API key, tenantId, datatableId y filePath al llamar a uploadFileToProcessMind().
 * - La URL base de la API es https://api.processmind.com
 */

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

/**
 * Sube un archivo a un datatable de ProcessMind usando una URL prefirmada.
 * @param {string} apiKey - Tu API key de autenticación.
 * @param {string} tenantId - Identificador de tu tenant.
 * @param {string} datatableId - Identificador del datatable.
 * @param {string} filePath - Ruta del archivo que quieres 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 al cargar desde la API: ${response.status}, ${response.statusText}: ${body.message}`);
            return;
        }
        return body;
    } catch (err) {
        console.error("Error inesperado:", 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("Subiendo archivo...");
        fs.readFile(filePath, async (err, data) => {
            if (err) {
                console.error("Error al leer el archivo:", err);
                return;
            }
            try {
                const uploadRes = await fetch(uploadUrl, {
                    method: "PUT",
                    body: data
                });
                if (!uploadRes.ok) {
                    console.error("Error al subir el archivo:", uploadRes.status, uploadRes.statusText);
                } else {
                    console.log("Archivo subido correctamente.");
                }
            } catch (uploadErr) {
                console.error("Error subiendo el archivo:", uploadErr);
            }
        });
    } catch (err) {
        console.error("Error inesperado:", err);
    }
}

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

Ejemplo Python: Subida de archivo CSV local

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

Pasos:

  1. Solicita una URL presigned de subida a la API.
  2. Lee el archivo local.
  3. Sube el archivo a la URL con 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 URL prefirmada.

Pasos:
1. Obtener una URL prefirmada desde la API.
2. Leer el archivo local desde disco.
3. Subir el archivo a la URL prefirmada utilizando PUT.

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

import requests

# === Configuración ===
api_key = ""  # API key para autenticación
tenant_id = ""  # Identificador del tenant
datatable_id = ""  # Identificador de la datatable
file_path = ""  # Ruta al archivo para subir


print("Obteniendo URL de subida...")
api_url = "https://api.processmind.com"  # URL base de la 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 obteniendo la URL de subida: {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 se devolvió una URL de subida presignada.")
	exit(1)

print("Subiendo archivo...")
with open(file_path, "rb") as f:
	upload_res = requests.put(upload_url, data=f)
if not upload_res.ok:
	print(f"Falló la subida: {upload_res.status_code}, {upload_res.reason}")
else:
	print("Archivo subido correctamente.")

info

Para documentación detallada sobre la API, incluyendo endpoints, autenticación, ejemplos y guías paso a paso para integración, visita nuestra Documentación API en GitHub. Si tienes dudas o necesitas ayuda con la API, contacta al equipo de soporte o únete a foros de la comunidad de developers.

Documentación relacionada