Liste des documents
Gestion des API Keys Appels API
Sur cette page
> ressources > docs > api > appels api > Appels API

Appels API

Comment effectuer des appels API à ProcessMind

Ce guide présente des exemples et bonnes pratiques pour utiliser l’API de ProcessMind. Que ce soit pour consulter des data, soumettre des infos ou automatiser vos workflows, il est essentiel de comprendre comment interagir avec notre API. Pour une doc complète de l’API, avec tous les endpoints, l’authentification, des exemples, formats de réponse et guides d’intégration, consultez notre documentation API sur GitHub.

Variables d’authentification

  • apiKey Pour toute requête API, incluez votre clé API dans les headers. Elle se trouve dans les paramètres ProcessMind.
  • tenantId Certains endpoints exigent l’ID du tenant pour spécifier le contexte. Cet ID est propre à votre orga et consultable dans vos paramètres.
  • datatableId Pour manipuler des datasets, indiquez l’ID de la datatable visée. Cet ID est affiché dans le menu paramètres du dataset [Get Data Table ID] sur ProcessMind.

Uploads directs de fichiers

ProcessMind permet d’uploader des fichiers directement dans les datatables via des URLs pré-signées. Cette méthode garantit un upload sécurisé sans exposer votre clé API ou d’autres infos sensibles. Attention : les URLs pré-signées expirent vite, utilisez-les dès leur obtention. Pour accéder à l’URL d’upload direct, faites une requête GET sur l’endpoint dédié. L’URL est aussi accessible via le menu de paramètres du dataset [Get upload URL] sur ProcessMind. Le temps d’expiration est réglable : 1 heure, 1 semaine ou 1 mois max.

Aperçu des endpoints API

MéthodeEndpointDescription
GET/tenant/{tenantId}/datatable/{datatableId}/uploads/presignedurlRetourne une URL pré-signée temporaire pour uploader un fichier dans une datatable.
GET/tenant/{tenantId}/datasetsListe les datasets pour le tenant donné.
GET/tenant/{tenantId}Détails sur le tenant indiqué.
GET/tenant/{tenantId}/organizationInfos sur l’organisation du tenant.

URL de base de l’API

Toutes les requêtes API doivent être faites à l’URL suivante : https://api.processmind.com

Obtenir une URL d’upload pré-signée

Endpoint : GET /tenant/{tenantId}/datatable/{datatableId}/uploads/presignedurl
Paramètres :

  • tenantId – ID du tenant (string).
  • datatableId – ID de la datatable à cibler (string).
  • apiKey – Votre clé API (string).

Retour :
Un objet avec PreSignedUploadUrl, une URL temporaire permettant d’uploader un fichier (d’habitude via HTTP PUT).

Exemple (avec helper) :

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

Lister les datasets

Endpoint : GET /tenant/{tenantId}/datasets
Paramètres :

  • tenantId – ID du tenant.
  • apiKey – Votre clé API.

Retour :
Un tableau d’objets datasets liés au tenant.

Exemple :

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

Voir les détails du tenant

Endpoint : GET /tenant/{tenantId}
Paramètres :

  • tenantId – ID du tenant.
  • apiKey – Votre clé API.

Retour :
Objet avec les métadonnées du tenant : nom, date création, type de plan.

Exemple :

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

Obtenir les détails de l’organisation

Endpoint : GET /tenant/{tenantId}/organization
Paramètres :

  • tenantId – ID du tenant.
  • apiKey – Votre clé API.

Retour :
Infos sur l’organisation du tenant (ex : nom entreprise, adresse, contacts).

Exemple :

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

Comment uploader un fichier

La fonction uploadFile montre comment envoyer un fichier via une URL pré-signée. Le principe :

  1. Obtenez l’URL pré-signée via getPresignedUploadUrl.
  2. Effectuez un PUT sur cette URL avec le fichier. L’URL pré-signée autorise le transfert direct, pas besoin d’autre identifiant.
  3. (Optionnel) Notifiez votre API si besoin que l’upload est fini, selon votre backend.

Exemple avec fetch :

async function uploadFile({ apiKey, tenantId, datatableId, file }) {
	// Étape 1 : obtenir une URL pré-signée
	const uploadUrl = await getPresignedUploadUrl({ apiKey, tenantId, datatableId });
	
	// Étape 2 : uploader en PUT
	await fetch(uploadUrl, {
		method: "PUT",
		headers: {
			"Content-Type": file.type
		},
		body: file
	});
	
	// Étape 3 : notifier votre API si besoin
	// (dépend de votre backend)
}

info

  • Une URL pré-signée expire très vite (souvent minutes). Utilisez-la dès réception.
  • Si l’upload échoue (ex : coupure réseau), demandez une nouvelle URL avant de réessayer.
  • Gardez votre apiKey confidentielle, ne l’exposez jamais côté client (front-end public).

Exemple Bash : Upload d’un fichier

Script Bash minimal pour uploader un fichier sur ProcessMind via deux commandes curl, avec variables à adapter.

Télécharger l’exemple BASH
#!/bin/bash
# Script Bash minimal pour uploader un fichier sur ProcessMind via deux appels curl, avec des variables à compléter

# Remplacez les valeurs ci-dessous par vos informations réelles :
# <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>" "{}"

Exemple Node.js : upload d’un CSV local

Envoie un fichier CSV local vers ProcessMind via une URL pré-signée.

Étapes :

  1. Récupérer l’URL via l’API.
  2. Lire le fichier local.
  3. Uploader le fichier par PUT sur l’URL donnée.

Configuration :

  • Indiquez API key, tenantId, datatableId et filePath à uploadFileToProcessMind().
  • URL de base API : https://api.processmind.com
Télécharger l’exemple NodeJS
/**
 * Téléverse un fichier CSV local sur ProcessMind via une URL présignée.
 *
 * Étapes :
 * 1. Récupérer une URL d’upload présignée via l’API.
 * 2. Lire le fichier local sur le disque.
 * 3. Envoyer le fichier à l’URL en utilisant HTTP PUT.
 *
 * Configuration :
 * - Indiquez votre API key, tenantId, datatableId et filePath lors de l’appel à uploadFileToProcessMind().
 * - L’URL de base de l’API est https://api.processmind.com
 */

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

/**
 * Téléverse un fichier dans une datatable ProcessMind via une URL présignée.
 * @param {string} apiKey - Votre API key pour l’authentification.
 * @param {string} tenantId - Identifiant du tenant.
 * @param {string} datatableId - Identifiant de la datatable.
 * @param {string} filePath - Chemin du fichier à téléverser.
 */

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(`Erreur lors du chargement depuis l’API : ${response.status}, ${response.statusText} : ${body.message}`);
            return;
        }
        return body;
    } catch (err) {
        console.error("Erreur inattendue :", 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("Téléversement du fichier en cours...");
        fs.readFile(filePath, async (err, data) => {
            if (err) {
                console.error("Erreur de lecture du fichier :", err);
                return;
            }
            try {
                const uploadRes = await fetch(uploadUrl, {
                    method: "PUT",
                    body: data
                });
                if (!uploadRes.ok) {
                    console.error("Téléversement échoué :", uploadRes.status, uploadRes.statusText);
                } else {
                    console.log("Fichier téléversé avec succès.");
                }
            } catch (uploadErr) {
                console.error("Erreur lors du téléversement du fichier :", uploadErr);
            }
        });
    } catch (err) {
        console.error("Erreur inattendue :", err);
    }
}

// Exporte la fonction pour l’utiliser dans d’autres modules
module.exports = { 
	getPresignedUploadUrl,
	getDatasets,
	getTenant,
	getOrganization,
	uploadFile 
};

Exemple Python : upload d’un CSV local

Dépose un CSV local sur l’API via une URL pré-signée.

Étapes :

  1. Récupérer l’URL via l’API.
  2. Lire le fichier local.
  3. Uploader via PUT à l’URL fournie.

Configuration :

  • Modifiez api_key, tenant_id, datatable_id et file_path selon besoin.
Télécharger l’exemple Python
"""
Téléverse un fichier CSV local vers une API distante avec une URL présignée.

Étapes :
1. Récupérer l’URL d’upload présignée via l’API.
2. Lire le fichier local sur le disque.
3. Envoyer le fichier à l’URL présignée avec HTTP PUT.

Configuration :
- Mettez à jour api_key, tenant_id, datatable_id, file_path selon vos besoins.
"""

import requests

# === Configuration ===
api_key = ""  # Clé API pour l'authentification
tenant_id = ""  # Identifiant du tenant
datatable_id = ""  # Identifiant du datatable
file_path = ""  # Chemin du fichier à uploader


print("Récupération de l’URL d’upload…")
api_url = "https://api.processmind.com"  # URL de base de l’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"Erreur lors de la récupération de l’URL d’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("Aucune URL d’upload presignée retournée.")
	exit(1)

print("Upload du fichier…")
with open(file_path, "rb") as f:
	upload_res = requests.put(upload_url, data=f)
if not upload_res.ok:
	print(f"Échec de l’upload : {upload_res.status_code}, {upload_res.reason}")
else:
	print("Fichier uploadé avec succès.")

info

Pour la documentation complète de l’API (endpoints, méthodes d’authentification, exemples de requêtes, formats de réponses, guides), consultez notre API Documentation sur GitHub. Pour toute question ou besoin d’aide sur l’API, contactez notre support ou rejoignez nos forums communauté développeurs.

Documentation associée