API d’automatisations #

Une automatisation est un flux de travail composé d’étapes : un ou plusieurs déclencheurs qui le lancent, suivis d’actions, de conditions, de délais, d’étapes d’IA et autres, connectés sous forme de graphe. Il s’agit de la même automatisation que celle que vous voyez et modifiez sur la page Automatisations. Ce guide explique comment les lire et les créer via l’API.

• URL de base : https://api.dmchamp.com/v1
• Authentification : votre clé API (voir Authentification)
• Erreurs : voir Erreurs et pagination et Erreurs ci-dessous

Tous les exemples ci-dessous montrent la forme de requête ?apiKey= en cURL et l’en-tête X-API-Key en JavaScript et Python. L’une ou l’autre fonctionne sur chaque point de terminaison.

Agences : chaque point de terminaison sur cette page accepte sub_account_id comme paramètre de requête, vous permettant ainsi de lire et de créer les automatisations d’un client avec votre clé d’agence. Un sub_account_id qui ne correspond pas à l’un de vos comptes clients renvoie 404. Voir API pour les agences.

Comment ça marche : le brouillon d’abord #

L’API est conçue de telle sorte que rien ne démarre par accident.

1. Lisez le catalogue. GET /automations/steps répertorie chaque type de déclencheur, d’action et d’étape que vous pouvez utiliser, ainsi que la grammaire pour écrire un graphe (graph_rules).
2. Créez un brouillon. POST /automations stocke l’automatisation désactivée. Rien ne s’exécute encore.
3. Vérifiez-le. Relisez-le, ouvrez-le dans le constructeur (la réponse vous donne son open_path) et assurez-vous que le propriétaire du compte a vu ce qu’il fait et pour qui.
4. Activez-le. POST /automations/{automationId}/enable est un appel spécifique. C’est l’étape qui déclenche des actions réelles : messages envoyés, enregistrements modifiés, outils fournis à un agent IA.

La modification ne change jamais l’état activé ou désactivé d’une automatisation. Cela signifie également qu’une modification apportée à une automatisation activée prend effet immédiatement, sur l’automatisation en cours d’exécution. Pour modifier une automatisation en cours d’exécution en toute sécurité, désactivez-la, modifiez-la, vérifiez-la, puis réactivez-la.

Chaque graphe que vous envoyez passe par les mêmes vérifications que celles appliquées par le canevas du constructeur. Un graphe qu’il ne peut pas ouvrir ou exécuter est refusé avec une 400 qui liste exactement ce qu’il faut corriger.

Accès #

• Le compte doit disposer des automatisations. Sans cela, chaque appel sur cette page renvoie 403.
• L’accès d’un membre de l’équipe suit sa zone Automatisations dans la Gestion d’équipe : la lecture (liste, obtenir, étapes, exécutions, dossiers) nécessite Voir, tout ce qui modifie quelque chose nécessite Modifier.
• Sur un compte client dont le forfait exclut la création et la modification d’automatisations, les appels d’écriture renvoient 403, exactement comme le fait le constructeur dans l’application.

L’objet automatisation #

La liste renvoie un résumé de chaque automatisation, sans ses étapes :

{
  "id": "8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f",
  "name": "Price question auto-reply",
  "description": "Replies with the price list when someone asks about prices.",
  "enabled": false,
  "updated_at": "2026-10-27T09:40:00.000Z",
  "trigger_kind": "incoming_message",
  "folder_id": "f1a2b3c4-5d6e-7f80-91a2-b3c4d5e6f708",
  "folder_name": "Sales"
}

La lecture d’une automatisation ajoute created_at et son graph :

{
  "id": "8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f",
  "name": "Price question auto-reply",
  "description": "Replies with the price list when someone asks about prices.",
  "enabled": false,
  "created_at": "2026-10-27T09:12:00.000Z",
  "updated_at": "2026-10-27T09:40:00.000Z",
  "trigger_kind": "incoming_message",
  "folder_id": null,
  "folder_name": null,
  "graph": {
    "nodes": [
      {
        "id": "trigger_1",
        "kind": "trigger",
        "label": "Incoming message",
        "alias": "incoming_message",
        "action": "incoming_message",
        "params": { "message_filter_contains": "price" },
        "config": { "kind": "incoming_message", "message_filter_contains": "price" }
      },
      {
        "id": "send_prices",
        "kind": "action",
        "label": "Send message",
        "alias": "send_message",
        "action": "SEND_MESSAGE",
        "params": { "contact_id": "${trigger.contact.id}", "body": "Hi ${trigger.contact.first_name}, here is our price list: https://example.com/prices" },
        "config": { "provider": "native", "slug": "SEND_MESSAGE", "params": { "contact_id": "${trigger.contact.id}", "body": "Hi ${trigger.contact.first_name}, here is our price list: https://example.com/prices" } }
      }
    ],
    "edges": [{ "from": "trigger_1", "to": "send_prices" }]
  }
}

Chaque étape (nodes[]) comporte :

Chaque connexion (edges[]) possède from et to (identifiants d’étapes), et branch lorsqu’elle suit une branche d’une étape, par exemple true ou false après une condition.

Deux éléments dans config sont modifiés lors de la sortie :

• Les secrets sont masqués. Les valeurs qui ressemblent à des identifiants (secrets de webhook, jetons, clés API, mots de passe, valeurs d’en-tête) sont renvoyées sous la forme "[redacted]". Renvoyez "[redacted]" inchangé et la valeur stockée sera conservée.
• Les textes longs sont raccourcis. Un texte unique de plus de 4 000 caractères environ est tronqué et se termine par des points de suspension. Si vous renvoyez cette étape, remettez d’abord son texte complet.

Lister les automatisations #

GET /automations renvoie les automatisations du compte, de la plus récemment modifiée à la plus ancienne, sous forme de résumés (sans les étapes).

Paramètres de requête (tous optionnels) : folder_id (uniquement les automatisations dans ce dossier, un identifiant provenant de Lister les dossiers, ou none pour celles qui ne sont dans aucun dossier), sub_account_id.

cURL

curl "https://api.dmchamp.com/v1/automations?apiKey=YOUR_API_KEY&folder_id=none"

JavaScript

const res = await fetch("https://api.dmchamp.com/v1/automations?folder_id=none", {
  headers: { "X-API-Key": "YOUR_API_KEY" },
});
const { automations } = await res.json();

Python

res = requests.get(
    "https://api.dmchamp.com/v1/automations",
    headers={"X-API-Key": "YOUR_API_KEY"},
    params={"folder_id": "none"},
)
automations = res.json()["automations"]

Réponse (200)

{ "success": true, "automations": [{ "id": "8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f", "name": "Price question auto-reply", "enabled": false, "...": "..." }] }

Si le service d’automatisation est injoignable, vous obtenez une 503, jamais une liste vide à la place. Une liste vide signifie toujours qu’il n’y a aucune automatisation.

Obtenir une automatisation #

GET /automations/{automationId} renvoie une automatisation avec son graphe complet : le type, l’étiquette, l’alias, l’action, les paramètres et les réglages de chaque étape, ainsi que les connexions entre elles.

curl "https://api.dmchamp.com/v1/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f?apiKey=YOUR_API_KEY"

const res = await fetch("https://api.dmchamp.com/v1/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f", {
  headers: { "X-API-Key": "YOUR_API_KEY" },
});
const { automation } = await res.json();

res = requests.get(
    "https://api.dmchamp.com/v1/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f",
    headers={"X-API-Key": "YOUR_API_KEY"},
)
automation = res.json()["automation"]

Réponse (200)

{ "success": true, "automation": { "id": "8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f", "name": "Price question auto-reply", "graph": { "nodes": ["..."], "edges": ["..."] } } }

Un identifiant qui n’existe pas sur ce compte renvoie 404.

Catalogue des étapes #

GET /automations/steps renvoie tout ce qui permet de construire une automatisation :

• node_kinds : les 8 types d’étape, chacun avec une étiquette et une description.
• triggers : chaque déclencheur pouvant lancer une automatisation, avec ses champs de paramètres (fields) et les valeurs qu’il transmet aux étapes suivantes (output_keys).
• actions : les actions intégrées qu’une étape d’action peut exécuter, chacune avec son key (le slug que vous utilisez dans un graphe) et son params, marqués required là où ils se trouvent.
• api_actions : les opérations de cette API qu’une étape d’action peut appeler. Sans q, elles sont renvoyées sous forme d’étiquettes regroupées par zone dans api_actions_by_tag, et la liste plate est vide, car il y en a plusieurs centaines.
• graph_rules : la grammaire pour écrire un graphe : les données que chaque type d’étape transporte, chaque type de déclencheur avec ses clés de paramètres, les fournisseurs d’actions, les noms de branche et la syntaxe de modèle. Lisez-la avant d’en créer ou d’en modifier un.
• counts : les totaux par liste, quelle que soit votre recherche.

C’est ce que le constructeur propose, et non ce que le compte a construit. Vérifiez cela avant de conclure qu’un déclencheur ou une action n’existe pas.

Paramètres de requête (tous optionnels) : q, un mot pour rechercher dans chaque liste (insensible à la casse), et sub_account_id.

Avec q :

• api_actions est la liste plate des correspondances, limitée à 60. api_actions_truncated est true lorsque la limite est atteinte. Les premières correspondances portent leurs paramètres.
• Les actions pour les applications tierces connectées sont également recherchées et renvoyées dans app_actions. Recherchez par le nom de l’application, par exemple q=hubspot. Chacune indique si le compte a cette application connectée (connected), et connected_apps liste les applications que le compte a connectées.
• app_actions_unavailable est true lorsque les actions de l’application n’ont pas pu être recherchées cette fois-ci. Les autres listes restent complètes.

curl "https://api.dmchamp.com/v1/automations/steps?apiKey=YOUR_API_KEY&q=tag"

const res = await fetch("https://api.dmchamp.com/v1/automations/steps?q=tag", {
  headers: { "X-API-Key": "YOUR_API_KEY" },
});
const { triggers, actions, graph_rules } = await res.json();

res = requests.get(
    "https://api.dmchamp.com/v1/automations/steps",
    headers={"X-API-Key": "YOUR_API_KEY"},
    params={"q": "tag"},
)
catalogue = res.json()

Réponse (200, raccourcie)

{
  "success": true,
  "q": "tag",
  "node_kinds": [{ "kind": "trigger", "label": "Trigger", "description": "Starts the automation when an event happens." }],
  "triggers": [
    {
      "kind": "tag_applied",
      "label": "Tag applied",
      "group": "Contacts",
      "fields": ["tag_name", "channel", "applied_by"],
      "output_keys": ["contact.id", "contact.first_name", "..."]
    }
  ],
  "actions": [
    {
      "key": "SET_CONTACT_TAG",
      "label": "Set contact tag",
      "group": "Contacts",
      "provider": "native",
      "params": [{ "key": "contact_id", "required": true }, { "key": "tag", "required": true }]
    }
  ],
  "api_actions": ["..."],
  "app_actions": [],
  "graph_rules": "GRAPH: { nodes: [{ id, type, label?, data }], edges: [{ source, target, sourceHandle? }] } ...",
  "counts": { "node_kinds": 8, "triggers": 40, "actions": 44, "api_actions": 454 }
}

Les listes de types d’étape et de déclencheurs ci-dessous sont extraites de ce point de terminaison. Le point de terminaison lui-même est toujours la liste actuelle.

Créer une automatisation #

POST /automations crée une automatisation à partir d’un nom et d’un graphe. Elle est enregistrée désactivée, en tant que brouillon.

Corps

Le graphe. graph_rules provenant du catalogue d’étapes est la grammaire complète. En résumé :

• Chaque nœud a un id (unique dans le graphe, par exemple trigger_1 ou send_reminder), un type (l’un des 8 types d’étape), un label optionnel, et ses paramètres dans data, sous une clé nommée d’après son type : data.trigger = { kind, ... }, data.action = { provider, slug, params }, data.condition = { ... }, data.delay = { seconds }, data.ai = { prompt }, data.loop = { over }, data.transform = { language, code }, data.respond = { status, body, content_type }.
• Une automatisation nécessite au moins un déclencheur. La grammaire active en autorise jusqu’à 10, et l’automatisation démarre lorsque l’un d’eux se déclenche.
• Toute autre étape doit être accessible depuis un déclencheur, et aucune connexion ne peut mener à une étape antérieure.
• Chaque arête a un source et un target. Les arêtes quittant une condition portent sourceHandle true ou false. Les arêtes quittant une boucle portent body ou done. Les arêtes quittant un délai « Attendre une réponse » portent replied ou timed_out. Les autres arêtes n’ont pas de sourceHandle ; la grammaire liste le reste.
• Les slugs d’action et les paramètres proviennent du catalogue. Ne devinez jamais un identifiant (un agent, une étiquette, une liste, une étape) : recherchez-le d’abord avec l’API, ou laissez le champ comme "" pour que la personne puisse choisir dans le constructeur.
• Les positions sont optionnelles. Les étapes sans position sont disposées automatiquement.
• Les valeurs des étapes précédentes sont écrites comme ${trigger.<field>} et ${nodes.<step>.<field>}. Voir Utiliser ce qu’une étape précédente a renvoyé et Expressions dans le guide des Automatisations.

Le graphe est accepté sous deux orthographes : celle du constructeur (nœuds avec type et data, arêtes avec source et target, comme ci-dessous) et celle avec laquelle Obtenir une automatisation répond (nœuds avec kind, config, action, params ; arêtes avec from, to, branch). Vous pouvez donc lire une automatisation, modifier une étape et la renvoyer.

curl -X POST "https://api.dmchamp.com/v1/automations?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Price question auto-reply",
    "description": "Replies with the price list when someone asks about prices.",
    "graph": {
      "nodes": [
        { "id": "trigger_1", "type": "trigger", "label": "Incoming message",
          "data": { "trigger": { "kind": "incoming_message", "message_filter_contains": "price" } } },
        { "id": "send_prices", "type": "action", "label": "Send message",
          "data": { "action": { "provider": "native", "slug": "SEND_MESSAGE",
            "params": { "contact_id": "${trigger.contact.id}", "body": "Hi ${trigger.contact.first_name}, here is our price list: https://example.com/prices" } } } }
      ],
      "edges": [{ "source": "trigger_1", "target": "send_prices" }]
    }
  }'

const res = await fetch("https://api.dmchamp.com/v1/automations", {
  method: "POST",
  headers: { "X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({ name: "Price question auto-reply", graph: { nodes, edges } }),
});
const { automation, draft, open_path, warnings } = await res.json();

res = requests.post(
    "https://api.dmchamp.com/v1/automations",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={"name": "Price question auto-reply", "graph": {"nodes": nodes, "edges": edges}},
)
draft = res.json()

Réponse (201)

{
  "success": true,
  "automation": { "id": "8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f", "name": "Price question auto-reply", "enabled": false, "graph": { "...": "..." } },
  "draft": true,
  "open_path": "/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f",
  "warnings": []
}

• automation est l’automatisation telle qu’elle est stockée, sous la même forme que Obtenir une automatisation.
• draft est true tant qu’elle est désactivée. Une nouvelle automatisation est toujours un brouillon jusqu’à ce que vous l’activiez, donc enabled: false ici est normal, ce n’est pas un échec.
• open_path est l’endroit où elle s’ouvre dans le constructeur de l’application.
• warnings liste les éléments que le constructeur n’a pas pu terminer, sous forme d’étiquettes courtes (par exemple agent_function:not_linked). Il est vide quand tout est propre.

Une création n’est pas sûre à répéter aveuglément. Si une requête expire, listez vos automatisations avant de l’envoyer à nouveau, sous peine de vous retrouver avec deux brouillons.

Mettre à jour une automatisation #

PUT /automations/{automationId} modifie le nom, la description et/ou le graphe. N’envoyez que les champs que vous souhaitez modifier.

Corps : name, description, graph (tous facultatifs, au moins un requis).

Un graph remplace le graphe entier, travaillez donc toujours à partir de ce qui est stocké :

1. Lisez l’automatisation avec GET /automations/{automationId}.
2. Modifiez ce dont vous avez besoin dans ce graphe.
3. Renvoyez le graphe complet, chaque étape incluse.

Lorsque vous le renvoyez :

• Gardez l’identifiant alias de chaque étape tel que vous l’avez reçu. Les étapes ultérieures font référence à une étape par son alias (${nodes.<alias>.<field>}). Si vous le modifiez ou le supprimez, chaque référence à cette étape deviendra vide. Voir Nommer vos étapes.
• Laissez les valeurs "[redacted]" telles quelles. Une valeur affichée comme "[redacted]" conserve sa valeur stockée.
• Restaurez les textes tronqués. Un texte qui revient avec des points de suspension a été raccourci lors de la lecture.

L’état d’activation de l’automatisation n’est jamais modifié ici. Si elle est activée, votre modification est effective dès qu’elle est enregistrée. Tant qu’une automatisation est activée, toute modification qui la ferait se déclencher elle-même est refusée : désactivez-la d’abord.

curl -X PUT "https://api.dmchamp.com/v1/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "Price question auto-reply (EN)" }'

// Read, edit, send back the whole graph
const get = await fetch(`https://api.dmchamp.com/v1/automations/${id}`, { headers: { "X-API-Key": "YOUR_API_KEY" } });
const { automation } = await get.json();
const step = automation.graph.nodes.find((n) => n.id === "send_prices");
step.config.params.body = "Hi ${trigger.contact.first_name}, our new price list: https://example.com/prices";
await fetch(`https://api.dmchamp.com/v1/automations/${id}`, {
  method: "PUT",
  headers: { "X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({ graph: automation.graph }),
});

url = f"https://api.dmchamp.com/v1/automations/{automation_id}"
automation = requests.get(url, headers={"X-API-Key": "YOUR_API_KEY"}).json()["automation"]
# ...edit automation["graph"] here, keeping every alias...
requests.put(url, headers={"X-API-Key": "YOUR_API_KEY"}, json={"graph": automation["graph"]})

Réponse (200) : la même forme qu’une création (automation, draft, open_path, warnings). N’envoyer aucun des champs name, description ou graph renvoie 400.

Activer et désactiver #

POST /automations/{automationId}/enable active une automatisation, afin qu’elle s’exécute désormais selon son déclencheur. N’appelez cette fonction qu’une fois que le propriétaire du compte a vu ce que fait l’automatisation, pour qui, et a accepté de l’activer. Le générateur refuse d’activer un graphe qu’il ne peut pas exécuter (pas de déclencheur, une boucle, une étape qui se déclenche elle-même) avec une erreur 400 expliquant pourquoi.

POST /automations/{automationId}/disable la désactive (la met en pause). Les exécutions déjà en cours se terminent ; aucune nouvelle exécution ne démarre. La désactivation est toujours autorisée.

Aucun de ces appels ne nécessite de corps.

curl -X POST "https://api.dmchamp.com/v1/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f/enable?apiKey=YOUR_API_KEY"

await fetch("https://api.dmchamp.com/v1/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f/disable", {
  method: "POST",
  headers: { "X-API-Key": "YOUR_API_KEY" },
});

requests.post(
    "https://api.dmchamp.com/v1/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f/enable",
    headers={"X-API-Key": "YOUR_API_KEY"},
)

Réponse (200) : l’automatisation telle qu’elle est stockée maintenant, sous la même forme qu’une création, avec draft: false après une activation.

Historique des exécutions #

GET /automations/{automationId}/runs renvoie les exécutions d’une automatisation, de la plus récente à la plus ancienne : quand chaque exécution a commencé et s’est terminée, ce qui l’a déclenchée, si elle a réussi, et l’erreur en cas d’échec. Lire l’automatisation vous indique ce qu’elle ferait. L’historique des exécutions vous indique ce qu’elle a fait, et c’est le seul moyen de distinguer une automatisation qui n’a jamais été exécutée d’une automatisation qui s’exécute et échoue à chaque fois.

Paramètres de requête (tous facultatifs) : limit (1 à 50, par défaut 10), sub_account_id.

curl "https://api.dmchamp.com/v1/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f/runs?apiKey=YOUR_API_KEY&limit=20"

const res = await fetch("https://api.dmchamp.com/v1/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f/runs?limit=20", {
  headers: { "X-API-Key": "YOUR_API_KEY" },
});
const { runs, note } = await res.json();

res = requests.get(
    "https://api.dmchamp.com/v1/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f/runs",
    headers={"X-API-Key": "YOUR_API_KEY"},
    params={"limit": 20},
)
runs = res.json()["runs"]

Réponse (200)

{
  "success": true,
  "automation": { "id": "8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f", "name": "Price question auto-reply", "enabled": true, "trigger_kind": "incoming_message" },
  "runs": [
    {
      "id": "run_7f3a",
      "status": "failed",
      "trigger_source": "incoming_message",
      "started_at": "2026-10-27T10:02:11.000Z",
      "finished_at": "2026-10-27T10:02:12.000Z",
      "error": "Contact is on Do Not Disturb list",
      "cancel_reason": null,
      "mode": "live"
    }
  ]
}

• mode est live pour une exécution réelle, ou safe pour une Exécution sécurisée depuis l’éditeur. Une exécution sécurisée n’envoie rien, ce n’est donc pas une preuve que l’automatisation fonctionne en conditions réelles.
• Une liste runs vide est une réponse valide, pas une lacune. La réponse contient alors un note : soit le déclencheur ne s’est jamais activé, soit l’automatisation est désactivée, donc rien n’a été exécuté.

Dossiers #

Les dossiers servent uniquement à regrouper les automatisations dans la liste. Ils ne modifient jamais le fonctionnement d’une automatisation ni son état (activée ou non). Voir Organiser les automatisations dans des dossiers.

Lister les dossiers #

GET /automations/folders renvoie les dossiers, chacun avec le nombre d’automatisations qu’il contient, plus unfiled_count : le nombre d’automatisations qui ne sont dans aucun dossier.

curl "https://api.dmchamp.com/v1/automations/folders?apiKey=YOUR_API_KEY"

{
  "success": true,
  "folders": [{ "id": "f1a2b3c4-5d6e-7f80-91a2-b3c4d5e6f708", "name": "Sales", "automation_count": 3 }],
  "unfiled_count": 5
}

Créer un dossier #

POST /automations/folders avec { "name": "Appointment reminders" }. Le nom est obligatoire, limité à 100 caractères, et doit être unique pour le compte. Classez-y des automatisations avec Déplacer une automatisation, ou transmettez folder_id lors de la création d’une automatisation.

curl -X POST "https://api.dmchamp.com/v1/automations/folders?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "Appointment reminders" }'

Réponse (201) : { "success": true, "folder": { "id": "...", "name": "Appointment reminders", "automation_count": 0 } }. Un nom déjà utilisé par un autre dossier renvoie 409 avec code: "folder_name_taken".

Renommer un dossier #

PUT /automations/folders/{folderId} avec { "name": "..." }. Les automatisations qu’il contient restent à leur place.

Réponse (200) : { "success": true, "folder": { ... } }.

Supprimer un dossier #

DELETE /automations/folders/{folderId} supprime uniquement le dossier. Les automatisations qu’il contient ne sont pas supprimées : elles ne sont plus dans aucun dossier et continuent de s’exécuter exactement comme avant.

curl -X DELETE "https://api.dmchamp.com/v1/automations/folders/f1a2b3c4-5d6e-7f80-91a2-b3c4d5e6f708?apiKey=YOUR_API_KEY"

{ "success": true, "deleted": true, "moved_to_no_folder": 3, "message": "Folder deleted. 3 automations were moved to No folder; no automation was deleted." }

Déplacer une automatisation vers un dossier #

PUT /automations/{automationId}/folder avec { "folder_id": "<folder id>" }, ou { "folder_id": null } pour la sortir de son dossier. folder_id est requis. Seule la liste où figure l’automatisation est modifiée.

curl -X PUT "https://api.dmchamp.com/v1/automations/8d2c7f1e-2a3b-4c5d-9e8f-0a1b2c3d4e5f/folder?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "folder_id": "f1a2b3c4-5d6e-7f80-91a2-b3c4d5e6f708" }'

Réponse (200) : { "success": true, "automation_id": "...", "folder_id": "..." }.

Catalogue #

Types d’étapes #

Déclencheurs #

Voici les 40 déclencheurs listés dans le catalogue aujourd’hui, regroupés comme le constructeur les organise. La colonne Paramètres contient les clés de configuration propres au déclencheur (fields), qui permettent d’affiner son exécution. Chaque déclencheur accepte également respect_quiet_hours, run_hours, reentry et stop_on_response ; voir Paramètres d’automatisation.

Messagerie

Contacts

Opportunités

Rendez-vous

Tâches

Compte

Agence

Général et applications

Une automatisation peut contenir au plus un déclencheur de chaque type parmi webhook, app_event, agent_function, rss, schedule, email_received, appointment_upcoming et contact_added. Un déclencheur qui s’active lors de la création d’un enregistrement ne peut pas être associé à l’action qui crée ce même enregistrement, car l’automatisation se déclencherait en boucle.

Pour savoir ce que chaque déclencheur transmet aux étapes suivantes (output_keys) et pour consulter la liste complète des actions avec leurs paramètres, lisez GET /automations/steps. Le guide des automatisations explique chaque déclencheur avec les termes utilisés dans le générateur.

Erreurs #

Chaque erreur suit la structure habituelle { "success": false, "error_code": <status>, "error": "..." }. Un graphe refusé ajoute code et errors :

{
  "success": false,
  "error_code": 400,
  "code": "invalid_graph",
  "error": "<the first problem, as one sentence>",
  "errors": ["<the first problem, as one sentence>", "<the next problem>"]
}

errors liste chaque problème, avec une phrase corrective pour chacun, et error est le premier. Corrigez exactement ce qui est listé et renvoyez le graphe complet. code est l’un des codes invalid_graph, automation_graph_has_a_cycle, self_triggering_automation, no_trigger, ou un autre code provenant du générateur.

Étapes suivantes #

• Automatisations : comment fonctionnent les déclencheurs, les étapes, les variables et l’historique d’exécution dans le générateur.
• API pour les agences : créez des automatisations sur un compte client avec sub_account_id.
• Référence de l’API : l’explorateur interactif complet des points de terminaison.