Dokumentenliste

Auf dieser Seite

> ressourcen > dokumente > api > api calls > API Calls

API Calls

API-Calls mit ProcessMind: Anleitung

In diesem Leitfaden finden Sie Beispiele und Best Practices zur Nutzung der ProcessMind-API. Egal ob Sie Daten abrufen, Informationen senden oder Workflows automatisieren: Das Verständnis der API ist entscheidend. Alle Details, Endpoints, Authentifizierung, Beispiele und Integrationsanleitungen finden Sie in unserer API Dokumentation auf GitHub.

Authentifizierungs-Variablen

apiKey Für alle API-Requests muss Ihr API-Key im Header stehen. Den Key finden Sie in den ProcessMind-Kontoeinstellungen.
tenantId Manche API-Endpunkte brauchen die Tenant ID als Kontext. Sie ist einzigartig für Ihre Organisation und ebenfalls unter Kontoeinstellungen.
datatableId Für Datasets benötigen Sie die Datatable ID. Diese im Dataset-Settings-Menü [Get Data Table ID] in ProcessMind abrufen.

Direkter Datei-Upload

ProcessMind ermöglicht direkten Datei-Upload in Datatables über presigned URLs. Sie laden so sicher hoch, ohne Ihren API-Key oder vertrauliche Infos weiterzugeben. Beachten Sie: presigned URLs sind zeitlich begrenzt und sollten rasch verwendet werden. Die Upload-URL erhalten Sie via GET zum Endpoint. Auch über das Dataset-Settings-Menü [Get upload URL] abrufbar. Zeitlimit: 1 Stunde, 1 Woche oder 1 Monat.

API-Endpoints im Überblick

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

API-Basis-URL

Alle API-Requests laufen über diese Basis-URL: https://api.processmind.com

Pre-signed Upload URL erhalten

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

tenantId – ID des Tenants (string).
datatableId – ID der Datatable (string).
apiKey – Ihr API-Key (string).

Antwort:
Ein Response-Objekt mit PreSignedUploadUrl – temporäre URL für den Datei-Upload (normalerweise via HTTP PUT).

Beispiel (mit 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.

Ergebnis:
Ein Array mit Dataset-Objekten für den Tenant.

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.

Ergebnis:
Objekt mit Metadaten zum Tenant; z.B. Name, Erstellungsdatum, 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.

Ergebnis:
Infos zur Organisation des Tenants (z.B. Firmenname, Adresse, Kontakt).

Beispiel:

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

Datei-Upload durchführen

Die Funktion uploadFile zeigt, wie Sie eine Datei mit einer pre-signed URL hochladen. Schritte:

Pre-signed URL mit getPresignedUploadUrl holen.
PUT-Request an diese URL mit der Datei senden. Die URL erlaubt direkten Upload zum Storage-Provider, keine weiteren Zugangsdaten nötig.
(Optional) API benachrichtigen, falls Ihr Backend das braucht.

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

async function uploadFile({ apiKey, tenantId, datatableId, file }) {
	// Schritt 1: Pre-signed URL holen
	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: Optional das Backend benachrichtigen
	// (abhängig von Ihrem Backend)
}

info

Pre-signed URLs laufen nach kurzer Zeit ab. Nutzen Sie sie direkt nach Abruf.
Scheitert der Upload (z.B. Verbindungsfehler), holen Sie eine neue URL vor erneutem Versuch.
Geben Sie Ihren apiKey niemals im öffentlichen Frontend preis.

Bash-Beispiel: Datei-Upload

Mini-Bash-Script zum Datei-Upload nach ProcessMind mit zwei curl-Calls. Platzhalter ersetzen.

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>" "{}"

Node.js-Beispiel: CSV-Upload

Upload einer lokalen CSV-Datei per presigned URL zu ProcessMind.

Ablauf:

Presigned Upload URL über API abrufen.
Datei lokal von der Festplatte lesen.
Datei per HTTP PUT an die URL hochladen.

Konfiguration:

apiKey, tenantId, datatableId und filePath an uploadFileToProcessMind() übergeben.
Die API-Basis-URL ist https://api.processmind.com

NodeJS Beispiel herunterladen

/**
 * Lädt eine lokale CSV-Datei per presigned URL zu ProcessMind hoch.
 *
 * Schritte:
 * 1. Hole eine presigned Upload-URL von der API.
 * 2. Lese die lokale Datei vom Datenträger.
 * 3. Lade die Datei per HTTP PUT auf die presigned URL hoch.
 *
 * Konfiguration:
 * - Geben Sie Ihren API-Key, tenantId, datatableId und filePath beim Aufruf von uploadFileToProcessMind() an.
 * - Die API-Basis-URL ist https://api.processmind.com
 */

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

/**
 * Lädt eine Datei per presigned URL in eine ProcessMind Datatable hoch.
 * @param {string} apiKey - Ihr API-Key zur Authentifizierung.
 * @param {string} tenantId - Ihr Tenant-Identifier.
 * @param {string} datatableId - Ihr Datatable-Identifier.
 * @param {string} filePath - Pfad zur Datei, die hochgeladen werden soll.
 */

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 Laden von der API: ${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 der Datei:", uploadErr);
            }
        });
    } catch (err) {
        console.error("Unerwarteter Fehler:", err);
    }
}

// Exportiert die Funktionen für andere Module
module.exports = { 
	getPresignedUploadUrl,
	getDatasets,
	getTenant,
	getOrganization,
	uploadFile 
};

Python-Beispiel: CSV-Upload

Lokale CSV-Datei per presigned URL zum API-Endpoint hochladen.

Ablauf:

Presigned Upload URL von der API holen.
Datei lokal einlesen.
Datei per HTTP PUT zur URL hochladen.

Konfig:

Passen Sie api_key, tenant_id, datatable_id und file_path an.

Python Beispiel herunterladen

"""
Lädt eine lokale CSV-Datei mit einer presigned URL zu einer externen API hoch.

Schritte:
1. Presigned Upload-URL bei der API abfragen.
2. Lokale Datei vom Datenträger lesen.
3. Datei per HTTP PUT auf die presigned URL hochladen.

Konfiguration:
- Aktualisieren Sie api_key, tenant_id, datatable_id, file_path entsprechend.
"""

import requests

# === Konfiguration ===
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 Laden 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("Keine presigned Upload-URL erhalten.")
	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.")

info

Alle Details zur API, inklusive Endpoints, Authentifizierung, Beispiele und Integrationsanleitungen finden Sie in unserer API-Dokumentation auf GitHub. Bei Fragen oder wenn Sie Hilfe zur API benötigen, wenden Sie sich gerne an unser Support-Team oder besuchen Sie unser Entwickler-Forum.