Lista de Documentos

Nesta Página

Chamadas API

Consumindo API do ProcessMind

Este guia mostra exemplos e práticas recomendadas para consumir a API do ProcessMind. Seja para buscar dados, enviar informações ou automatizar workflows, é essencial saber como usar nossa API.

Variáveis de autenticação

apiKey Para todas as requisições à API, inclua sua chave de API no header do request para autenticação. A chave está nas configurações da sua conta ProcessMind.
tenantId Alguns endpoints da API exigem o Tenant ID para definir o contexto da requisição. Esse ID é exclusivo da sua organização e também está disponível nas configurações da conta.
datatableId Ao trabalhar com dataset, informe o Datatable ID para indicar qual tabela está sendo usada. O ID aparece no menu de configurações do dataset em [Get Data Table ID] no ProcessMind.

Upload direto de arquivos

O ProcessMind permite upload direto de arquivos para datatables usando presigned URLs. Esse método garante envio seguro sem expor sua API key ou outras informações sensíveis. Lembre-se de que presigned URLs têm validade limitada e devem ser usadas logo após serem geradas. Para acessar a URL de upload direto, faça uma chamada GET para o endpoint correto. Você pode obter essa URL no menu de configurações do dataset em [Get upload URL] dentro do ProcessMind. O prazo pode ser de 1 hora, 1 semana ou 1 mês no máximo.

Visão geral dos endpoints

Método	Endpoint	Descrição
GET	`/tenant/{tenantId}/datatable/ {datatableId}/uploads/presignedurl`	Retorna uma URL pré-assinada temporária para upload de arquivo em um datatable.
GET	`/tenant/{tenantId}/datasets`	Retorna uma lista de datasets do tenant informado.
GET	`/tenant/{tenantId}`	Retorna detalhes do tenant especificado.
GET	`/tenant/{tenantId}/organization`	Retorna informações da organização do tenant.

Base URL

Todas as requisições para API devem ser feitas na seguinte base URL: https://api.processmind.com

Como obter uma URL de upload pré-assinada

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

tenantId – ID do tenant (string).
datatableId – ID do datatable (string).
apiKey – Sua API key (string).

Retorno: Objeto com o campo PreSignedUploadUrl, que será uma URL temporária para upload direto do arquivo (normalmente via HTTP PUT).

Exemplo (usando helper):

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

Listando Datasets

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

tenantId – ID do tenant.
apiKey – Sua API key.

Retorno: Um array de objetos de dataset do tenant.

Exemplo:

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

Consultando informações do Tenant

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

tenantId – ID do tenant.
apiKey – Sua API key.

Retorno: Um objeto com metadados do tenant, como nome, data de criação e plano.

Exemplo:

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

Obtendo dados da Organização

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

tenantId – ID do tenant.
apiKey – Sua API key.

Retorno: Informações da organização vinculada ao tenant (ex: nome da empresa, endereço e contatos).

Exemplo:

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

Upload de arquivo

A função uploadFile mostra como fazer upload de um arquivo usando uma URL pré-assinada. O fluxo é:

Obtenha a URL pré-assinada com o getPresignedUploadUrl.
Faça um PUT para essa URL com o arquivo. A URL pré-assinada permite o envio direto ao storage provider, sem precisar de credenciais extras.
(Opcional) Avise a API que o upload foi concluído, se necessário pelo backend.

Veja um exemplo simples usando fetch para subir um arquivo:

async function uploadFile({ apiKey, tenantId, datatableId, file }) {
  // Passo 1: Obtenha a URL pré-assinada
  const uploadUrl = await getPresignedUploadUrl({ apiKey, tenantId, datatableId });
  
  // Passo 2: Envie o arquivo via PUT
  await fetch(uploadUrl, {
    method: 'PUT',
    headers: {
      'Content-Type': file.type
    },
    body: file
  });
  
  // Passo 3: (Opcional) Avise a API da conclusão
  // (depende do backend)
}

info

URLs pré-assinadas expiram em poucos minutos. Use logo após gerar.
Se o upload falhar (ex.: rede), gere nova URL antes de tentar de novo.
Mantenha seu apiKey seguro e nunca exponha no cliente (ex.: front-end público).

Exemplo BASH

Script Bash simples para enviar arquivo ao ProcessMind usando dois comandos curl, com variáveis substituíveis

Download Exemplo BASH

#!/bin/bash
# Script Bash simples para enviar um arquivo ao ProcessMind usando dois comandos curl, com placeholders para todos os valores

# Substitua os placeholders abaixo pelos seus valores reais:
# <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>" "{}"

Exemplo NodeJS

Envia um CSV local para o ProcessMind usando URL presignada.

Passos:

Buscar URL presignada de upload via API.
Ler o arquivo local.
Fazer upload para a URL via HTTP PUT.

Configuração:

Informe sua API key, tenantId, datatableId e filePath ao usar uploadFileToProcessMind().
A URL base da API é https://api.processmind.com

Download Exemplo NodeJS

/**
 * Envia um arquivo CSV local para o ProcessMind via URL presignada.
 *
 * Passos:
 * 1. Buscar URL presignada pela API.
 * 2. Ler o arquivo local.
 * 3. Enviar para a URL via HTTP PUT.
 *
 * Configuração:
 * - Use API key, tenantId, datatableId e filePath na chamada uploadFileToProcessMind().
 * - URL base da API: https://api.processmind.com
 */

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

/**
 * Faz upload de arquivo para datatable ProcessMind via URL presignada.
 * @param {string} apiKey - Sua API key para autenticação.
 * @param {string} tenantId - ID do tenant.
 * @param {string} datatableId - ID da datatable.
 * @param {string} filePath - Caminho do arquivo local para upload.
 */

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(`Erro ao carregar da API: ${response.status}, ${response.statusText}: ${body.message}`);
            return;
        }
        return body;
    } catch (err) {
        console.error("Erro 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("Enviando arquivo...");
        fs.readFile(filePath, async (err, data) => {
            if (err) {
                console.error("Erro ao ler o arquivo:", err);
                return;
            }
            try {
                const uploadRes = await fetch(uploadUrl, {
                    method: "PUT",
                    body: data
                });
                if (!uploadRes.ok) {
                    console.error("Falha no upload:", uploadRes.status, uploadRes.statusText);
                } else {
                    console.log("Arquivo enviado com sucesso.");
                }
            } catch (uploadErr) {
                console.error("Erro ao fazer upload:", uploadErr);
            }
        });
    } catch (err) {
        console.error("Erro inesperado:", err);
    }
}

// Exporta funções para uso em outros módulos
module.exports = { 
	getPresignedUploadUrl,
	getDatasets,
	getTenant,
	getOrganization,
	uploadFile 
};

Exemplo em Python

Envia um arquivo CSV local para uma API remota usando uma URL pré-assinada.

Passos:

Busque a URL de upload pré-assinada na API.
Leia o arquivo local do disco.
Envie o arquivo para a URL pré-assinada usando HTTP PUT.

Configuração:

Atualize api_key, tenant_id, datatable_id e file_path conforme necessário.

Download Exemplo Python

"""
Envia um arquivo CSV local para uma API remota usando uma URL pré-assinada.

Passos:
1. Busque a URL de upload pré-assinada na API.
2. Leia o arquivo local do disco.
3. Envie o arquivo para a URL pré-assinada usando HTTP PUT.

Configuração:
- Atualize api_key, tenant_id, datatable_id e file_path conforme necessário.
"""

import requests

# === Configuração ===
api_key = ""  # Chave de API para autenticação
tenant_id = ""  # ID do tenant
datatable_id = ""  # ID da datatable
file_path = ""  # Caminho do arquivo para upload


print("Buscando URL de upload...")
api_url = "https://api.processmind.com"  # URL base da 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"Erro ao buscar URL de upload: {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("URL de upload não retornada.")
	exit(1)

print("Enviando arquivo...")
with open(file_path, "rb") as f:
	upload_res = requests.put(upload_url, data=f)
if not upload_res.ok:
	print(f"Falha no upload: {upload_res.status_code}, {upload_res.reason}")
else:
	print("Arquivo enviado com sucesso.")

Documentação Relacionada

Gestão de API Keys

Gerencie suas API keys com facilidade para integrar o ProcessMind aos seus apps com segurança e eficiência.