Dokumentenliste

Auf dieser Seite

> ressourcen > dokumente > api > API Calls

API Calls

API-Calls mit ProcessMind

Diese Anleitung liefert Beispiele und Best Practices für API-Requests an die ProcessMind Services. Egal ob Sie Daten abrufen, Informationen senden oder Workflows automatisieren – ein Grundverständnis der API ist wichtig.

Authentifizierungsvariablen

apiKey Für alle API-Anfragen muss Ihr API-Key im Anfrage-Header zur Authentifizierung angegeben werden. Den API-Key finden Sie in den Einstellungen Ihres ProcessMind-Accounts.
tenantId Manche API-Endpunkte erfordern eine Tenant ID, um den Kontext der Anfrage festzulegen. Diese ID ist eindeutig für Ihre Organisation und auch in den Kontoeinstellungen abrufbar.
datatableId Beim Arbeiten mit Datasets geben Sie die Datatable ID an, um die jeweilige Datatable zu identifizieren. Diese ID finden Sie im Dataset-Einstellungsmenü unter [Get Data Table ID] in ProcessMind.

Direkter Datei-Upload

ProcessMind unterstützt direkte Datei-Uploads in Datatables mit presigned URLs. Damit laden Sie Dateien sicher hoch, ohne Ihren API Key oder andere sensible Infos preiszugeben. Beachten Sie: Presigned URLs sind zeitlich begrenzt und sollten direkt nach Erhalt verwendet werden. Um die Upload-URL abzurufen, führen Sie eine GET-Anfrage zum Endpoint aus. Die URL erhalten Sie im Dataset-Einstellungsmenü unter [Get upload URL] bei ProcessMind. Die maximale Laufzeit ist 1 Stunde, 1 Woche oder 1 Monat.

Endpoint-Übersicht

Methode	Endpoint	Beschreibung
GET	`/tenant/{tenantId}/datatable/{datatableId}/uploads/presignedurl`	Gibt eine temporäre, vor-signierte URL für den Datei-Upload in eine Datatable zurück.
GET	`/tenant/{tenantId}/datasets`	Listet die Datasets für den angegebenen Tenant auf.
GET	`/tenant/{tenantId}`	Gibt Details zum angegebenen Tenant zurück.
GET	`/tenant/{tenantId}/organization`	Zeigt Informationen zur Organisation des Tenants an.

Base URL

Alle API-Anfragen gehen an folgende Base URL: https://api.processmind.com

Pre‑signed Upload-URL abrufen

Endpoint: GET /tenant/{tenantId}/datatable/{datatableId}/uploads/presignedurl Parameter:

tenantId – ID des Tenants (String).
datatableId – ID der Datatable, in die hochgeladen werden soll (String).
apiKey – Ihr API-Key (String).

Antwort: Ein Response-Objekt mit der PreSignedUploadUrl, einer temporären URL zum direkten Datei-Upload (meist via HTTP PUT).

Beispiel (mit dem Helper):

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

Datasets auflisten

Endpoint: GET /tenant/{tenantId}/datasets Parameter:

tenantId – ID des Tenants.
apiKey – Ihr API-Key.

Antwort: Ein Array von Dataset-Objekten, die zu diesem Tenant gehören.

Beispiel:

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

Tenant-Details abrufen

Endpoint: GET /tenant/{tenantId} Parameter:

tenantId – ID des Tenants.
apiKey – Ihr API-Key.

Antwort: Ein Objekt mit Metadaten zum Tenant wie Name, Erstellungsdatum und Tarif.

Beispiel:

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

Organisationsdetails abrufen

Endpoint: GET /tenant/{tenantId}/organization Parameter:

tenantId – ID des Tenants.
apiKey – Ihr API-Key.

Antwort: Informationen zur Organisation des Tenants (z.B. Firmenname, Adresse, Kontaktdaten).

Beispiel:

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

Datei-Upload durchführen

Die Funktion uploadFile zeigt, wie eine Datei mit einer vor-signierten URL hochgeladen wird. Der Ablauf:

Pre‑signed URL mit getPresignedUploadUrl abrufen.
Datei mit einem PUT-Request an diese URL hochladen. Die vor-signierte URL erlaubt den direkten Upload beim Storage-Provider, weitere Zugangsdaten sind nicht erforderlich.
(Optional) API informieren, dass der Upload abgeschlossen ist, falls Ihr Backend dies verlangt.

Hier ein einfaches Beispiel mit fetch für den Datei-Upload:

async function uploadFile({ apiKey, tenantId, datatableId, file }) {
  // Schritt 1: Pre-signed URL abrufen
  const uploadUrl = await getPresignedUploadUrl({ apiKey, tenantId, datatableId });
  
  // Schritt 2: Datei via PUT hochladen
  await fetch(uploadUrl, {
    method: 'PUT',
    headers: {
      'Content-Type': file.type
    },
    body: file
  });
  
  // Schritt 3: Optionale Benachrichtigung an Ihre API
  // (abhängig vom Backend)
}

info

Pre-signed URLs laufen nach einer festgelegten Zeit (oft Minuten) ab. Nutzen Sie die URL direkt nach dem Abruf.
Schlägt der Upload fehl (z.B. Netzunterbrechung), holen Sie eine neue vor-signierte URL, bevor Sie es erneut versuchen.
Bewahren Sie Ihren apiKey stets sicher auf und veröffentlichen Sie ihn nicht im Client (z.B. im öffentlichen Frontend).

BASH Beispiel

Minimales Bash-Skript, um eine Datei per curl bei ProcessMind hochzuladen (Platzhalter für alle Werte)

BASH Beispiel herunterladen

#!/bin/bash
# Minimales Bash-Skript zum Hochladen einer Datei nach ProcessMind mit zwei curl-Befehlen, Platzhalter für alle Werte

# Ersetzen Sie die folgenden Platzhalter durch Ihre echten Werte:
# <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>" "{}"

NodeJS Beispiel

Lädt eine lokale CSV-Datei per presigned URL zu ProcessMind hoch.

Schritte:

Presigned Upload-URL via API abrufen
Lokale Datei vom System einlesen
Datei per HTTP PUT auf die Upload-URL übertragen

Konfiguration:

API-Key, tenantId, datatableId und filePath in uploadFileToProcessMind() angeben.
Die Basis-API-URL ist https://api.processmind.com

NodeJS Beispiel herunterladen

/**
 * Lädt eine lokale CSV-Datei mit einer presigned URL zu ProcessMind hoch.
 *
 * Schritte:
 * 1. Upload-URL vom API holen
 * 2. Datei von Festplatte einlesen
 * 3. Datei per HTTP PUT an die presigned URL senden
 *
 * Konfiguration:
 * - API-Key, tenantId, datatableId, filePath beim Aufruf von uploadFileToProcessMind() angeben.
 * - Die API-Basis-URL ist https://api.processmind.com
 */

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

/**
 * Überträgt eine Datei per presigned URL in die Datatable von ProcessMind.
 * @param {string} apiKey - Ihr API-Key für die Authentifizierung.
 * @param {string} tenantId - Ihre Tenant-ID.
 * @param {string} datatableId - Ihre Datatable-ID.
 * @param {string} filePath - Pfad zur hochzuladenden Datei.
 */

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(`Fehler beim API-Request: ${response.status}, ${response.statusText}: ${body.message}`);
            return;
        }
        return body;
    } catch (err) {
        console.error("Unerwarteter Fehler:", 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("Datei wird hochgeladen...");
        fs.readFile(filePath, async (err, data) => {
            if (err) {
                console.error("Fehler beim Lesen der Datei:", err);
                return;
            }
            try {
                const uploadRes = await fetch(uploadUrl, {
                    method: "PUT",
                    body: data
                });
                if (!uploadRes.ok) {
                    console.error("Upload fehlgeschlagen:", uploadRes.status, uploadRes.statusText);
                } else {
                    console.log("Datei erfolgreich hochgeladen.");
                }
            } catch (uploadErr) {
                console.error("Fehler beim Hochladen:", uploadErr);
            }
        });
    } catch (err) {
        console.error("Unerwarteter Fehler:", err);
    }
}

// Exportiert die Funktionen zur Verwendung in anderen Modulen
module.exports = { 
	getPresignedUploadUrl,
	getDatasets,
	getTenant,
	getOrganization,
	uploadFile 
};

Python Beispiel

Lädt eine lokale CSV-Datei per presigned URL zu einer entfernten API hoch.

Schritte:

Eine presigned Upload-URL von der API abrufen
Datei lokal von der Festplatte einlesen
Datei per HTTP PUT an die presigned URL senden

Konfiguration:

api_key, tenant_id, datatable_id, file_path entsprechend anpassen.

Python Beispiel herunterladen

"""
Lädt eine lokale CSV-Datei per presigned URL zur API hoch.

Schritte:
1. Presigned Upload-URL via API holen
2. Lokale Datei auslesen
3. Datei per HTTP PUT auf die Upload-URL übertragen

Konfiguration:
- api_key, tenant_id, datatable_id, file_path anpassen
"""

import requests

# === Configuration ===
api_key = ""  # API-Key für Authentifizierung
tenant_id = ""  # Tenant ID
datatable_id = ""  # Datatable ID
file_path = ""  # Pfad zur hochzuladenden Datei


print("Upload-URL wird abgerufen...")
api_url = "https://api.processmind.com"  # Basis API-URL
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"Fehler beim Abrufen der 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("Es wurde keine presigned Upload-URL zurückgegeben.")
	exit(1)

print("Datei wird hochgeladen...")
with open(file_path, "rb") as f:
	upload_res = requests.put(upload_url, data=f)
if not upload_res.ok:
	print(f"Upload fehlgeschlagen: {upload_res.status_code}, {upload_res.reason}")
else:
	print("Datei erfolgreich hochgeladen.")