API Automazioni #

Un’automazione è un flusso di lavoro composto da passaggi: uno o più trigger che lo avviano, seguiti da azioni, condizioni, ritardi, passaggi IA e altro ancora, collegati in un grafo. È la stessa automazione che vedi e modifichi nella pagina Automazioni. Questa guida illustra come leggerle e crearle tramite l’API.

• URL di base: https://api.dmchamp.com/v1
• Autenticazione: la tua chiave API (vedi Autenticazione)
• Errori: vedi Errori e impaginazione ed Errori di seguito

Tutti gli esempi seguenti mostrano il formato di query ?apiKey= in cURL e l’intestazione X-API-Key in JavaScript e Python. Entrambi funzionano su ogni endpoint.

Agenzie: ogni endpoint in questa pagina accetta sub_account_id come parametro di query, così puoi leggere e creare le automazioni di un cliente con la tua chiave di agenzia. Un sub_account_id che non appartiene a uno dei tuoi account cliente restituisce 404. Vedi API per le agenzie.

Come funziona: prima la bozza #

L’API è strutturata in modo che nulla venga avviato accidentalmente.

1. Leggi il catalogo. GET /automations/steps elenca ogni trigger, azione e tipo di passaggio che puoi utilizzare, oltre alla grammatica per scrivere un grafo (graph_rules).
2. Crea una bozza. POST /automations memorizza l’automazione disattivata. Non viene eseguito ancora nulla.
3. Controllala. Leggila, aprila nel builder (la risposta ti fornisce il suo open_path) e assicurati che il proprietario dell’account abbia visto cosa fa e a chi si rivolge.
4. Attivala. POST /automations/{automationId}/enable è una chiamata a sé stante. Questo è il passaggio che rende operative le azioni: messaggi inviati, record modificati, strumenti forniti a un agente IA.

La modifica non cambia mai lo stato di attivazione di un’automazione. Ciò significa anche che una modifica a un’automazione attiva ha effetto immediato sull’automazione in esecuzione. Per modificare un’automazione in esecuzione in modo sicuro, disabilitala, modificala, controllala e riabilitala.

Ogni grafo inviato viene sottoposto agli stessi controlli applicati dal canvas del builder. Un grafo che non può essere aperto o eseguito viene rifiutato con un 400 che elenca esattamente cosa correggere.

Accesso #

• L’account deve disporre di Automazioni. Senza di esse, ogni chiamata in questa pagina restituisce 403.
• L’accesso di un membro del team segue la sua area Automazioni in Gestione Team: la lettura (elenco, recupero, passaggi, esecuzioni, cartelle) richiede Visualizzazione, tutto ciò che comporta una modifica richiede Modifica.
• Su un account cliente il cui piano non prevede la creazione e la modifica di automazioni, le chiamate di scrittura restituiscono 403, esattamente come fa il builder nell’app.

L’oggetto automazione #

L’elenco restituisce un riepilogo di ogni automazione, senza i relativi passaggi:

{
  "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 lettura di un’automazione aggiunge created_at e il suo 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" }]
  }
}

Ogni passaggio (nodes[]) contiene:

Ogni connessione (edges[]) ha from e to (id dei passaggi), e branch quando segue un ramo di un passaggio, ad esempio true o false dopo una condizione.

Due elementi in config vengono modificati in uscita:

• I segreti sono nascosti. I valori che sembrano credenziali (segreti webhook, token, chiavi API, password, valori di intestazione) vengono restituiti come "[redacted]". Invia "[redacted]" indietro invariato e il valore memorizzato verrà mantenuto.
• I testi lunghi sono abbreviati. Un singolo testo più lungo di circa 4.000 caratteri viene troncato e termina con un’ellissi. Se invii quel passaggio indietro, inserisci prima il suo testo completo.

Elenca automazioni #

GET /automations restituisce le automazioni sull’account, ordinate dalla più recentemente modificata, come riepiloghi (senza passaggi).

Parametri di query (tutti facoltativi): folder_id (solo le automazioni in quella cartella, un id da Elenca cartelle, o none per quelle non in alcuna cartella), 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"]

Risposta (200)

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

Se il servizio di automazione non è raggiungibile, si ottiene un 503, mai una lista vuota al suo posto. Una lista vuota significa sempre che non ci sono automazioni.

Ottieni un’automazione #

GET /automations/{automationId} restituisce un’automazione con il suo grafo completo: tipo, etichetta, alias, azione, parametri e impostazioni di ogni passaggio, oltre alle connessioni tra di essi.

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"]

Risposta (200)

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

Un id che non è presente su questo account restituisce 404.

Catalogo dei passaggi #

GET /automations/steps restituisce tutto ciò con cui può essere costruita un’automazione:

• node_kinds: gli 8 tipi di passaggio, ognuno con un’etichetta e una descrizione.
• triggers: ogni trigger che può avviare un’automazione, con i relativi campi di impostazione (fields) e i valori che trasmette ai passaggi successivi (output_keys).
• actions: le azioni integrate che un passaggio di azione può eseguire, ognuna con il proprio key (lo slug utilizzato in un grafo) e il proprio params, contrassegnato come required dove presente.
• api_actions: le operazioni di questa API che un passaggio di azione può richiamare. Senza q, vengono restituite come etichette raggruppate per area in api_actions_by_tag, e l’elenco semplice è vuoto, poiché ce ne sono diverse centinaia.
• graph_rules: la grammatica per scrivere un grafo: i dati che ogni tipo di passaggio trasporta, ogni tipo di trigger con le relative chiavi di impostazione, i provider di azioni, i nomi dei rami e la sintassi del modello. Leggila prima di crearne o modificarne uno.
• counts: i totali per elenco, indipendentemente da ciò che hai cercato.

Questo è ciò che il builder offre, non ciò che l’account ha costruito. Controllalo prima di concludere che un trigger o un’azione non esistano.

Parametri di query (tutti facoltativi): q, una parola per cercare in ogni elenco (senza distinzione tra maiuscole e minuscole), e sub_account_id.

Con q:

• api_actions è l’elenco semplice delle corrispondenze, limitato a 60. api_actions_truncated è true quando il limite è stato applicato. Le prime corrispondenze contengono i relativi parametri.
• Vengono cercate anche le azioni per app di terze parti connesse, che vengono restituite in app_actions. Cerca per nome dell’app, ad esempio q=hubspot. Ognuna indica se l’account ha quell’app connessa (connected), e connected_apps elenca le app che l’account ha connesso.
• app_actions_unavailable è true quando le azioni dell’app non sono state cercate questa volta. Gli altri elenchi rimangono completi.

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()

Risposta (200, abbreviata)

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

Gli elenchi di tipi di passaggio e trigger qui sotto sono tratti da questo endpoint. L’endpoint stesso è sempre l’elenco corrente.

Creare un’automazione #

POST /automations crea un’automazione a partire da un nome e un grafo. Viene archiviata disattivata, come bozza.

Corpo

Il grafo. graph_rules dal catalogo dei passaggi è la grammatica completa. In breve:

• Ogni nodo ha un id (univoco nel grafo, ad esempio trigger_1 o send_reminder), un type (uno degli 8 tipi di passaggio), un label facoltativo e le sue impostazioni in data, sotto una chiave che prende il nome dal suo tipo: 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 }.
• Un’automazione necessita di almeno un trigger. La grammatica live ne consente fino a 10 e l’automazione si avvia quando uno di essi viene attivato.
• Ogni altro passaggio deve essere raggiungibile da un trigger e nessuna connessione può riportare a un passaggio precedente.
• Ogni arco ha un source e un target. Gli archi che escono da una condizione portano sourceHandle true o false. Gli archi che escono da un ciclo portano body o done. Gli archi che escono da un ritardo di “Attesa risposta” portano replied o timed_out. Altri archi non hanno sourceHandle; la grammatica elenca il resto.
• Gli slug e i parametri delle azioni provengono dal catalogo. Non indovinare mai un id (un agente, un tag, un elenco, una fase): cercalo prima con l’API o lascia il campo come "" affinché la persona possa sceglierlo nel builder.
• Le posizioni sono facoltative. I passaggi senza una posizione vengono disposti automaticamente.
• I valori dei passaggi precedenti sono scritti come ${trigger.<field>} e ${nodes.<step>.<field>}. Vedi Utilizzo di ciò che ha restituito un passaggio precedente ed Espressioni nella guida alle Automazioni.

Il grafo è accettato in due grafie: quella del builder (nodi con type e data, archi con source e target, come di seguito) e quella con cui risponde Ottieni un’automazione (nodi con kind, config, action, params; archi con from, to, branch). Quindi puoi leggere un’automazione, modificare un passaggio e rispedirlo.

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()

Risposta (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 è l’automazione archiviata, nella stessa forma di Ottieni un’automazione.
• draft è true mentre è disattivata. Una nuova automazione è sempre una bozza finché non la abiliti, quindi enabled: false qui è normale, non un errore.
• open_path è dove si apre nel builder dell’app.
• warnings elenca le cose che il builder non è riuscito a completare, come etichette brevi (ad esempio agent_function:not_linked). È vuoto quando tutto è corretto.

Un’operazione di creazione non è sicura da ripetere ciecamente. Se una richiesta va in timeout, elenca le tue automazioni prima di inviarla di nuovo, altrimenti potresti ritrovarti con due bozze.

Aggiorna un’automazione #

PUT /automations/{automationId} modifica il nome, la descrizione e/o il grafo. Invia solo i campi che desideri modificare.

Corpo: name, description, graph (tutti facoltativi, almeno uno).

Un graph sostituisce l’intero grafo, quindi lavora sempre partendo da ciò che è archiviato:

1. Leggi l’automazione con GET /automations/{automationId}.
2. Modifica ciò di cui hai bisogno in quel grafo.
3. Invia indietro l’intero grafo, inclusi tutti i passaggi.

Quando lo invii indietro:

• Mantieni ogni alias di ogni passaggio esattamente come l’hai ricevuto. I passaggi successivi fanno riferimento a un passaggio tramite il suo alias (${nodes.<alias>.<field>}). Se lo modifichi o lo elimini, ogni riferimento a quel passaggio risulterà vuoto. Vedi Assegnare un nome ai passaggi.
• Lascia i valori "[redacted]" così come sono. Un valore mostrato come "[redacted]" mantiene il suo valore memorizzato.
• Ripristina i testi abbreviati. Un testo che termina con un’ellissi è stato troncato durante la lettura.

Lo stato di attivazione dell’automazione non viene mai modificato qui. Se è attiva, la tua modifica sarà effettiva non appena verrà salvata. Mentre un’automazione è attiva, una modifica che potrebbe causare un’auto-attivazione verrà rifiutata: disabilitala prima.

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"]})

Risposta (200): la stessa struttura di una creazione (automation, draft, open_path, warnings). L’invio di nessuno tra name, description o graph restituisce 400.

Abilita e disabilita #

POST /automations/{automationId}/enable attiva un’automazione, in modo che venga eseguita al verificarsi del suo trigger da questo momento in poi. Richiamalo solo dopo che il proprietario dell’account ha visto cosa fa l’automazione e a chi, e ha acconsentito ad attivarla. Il builder rifiuta di attivare un grafo che non può essere eseguito (nessun trigger, un ciclo, un passaggio che attiva se stesso) con un 400 che ne spiega il motivo.

POST /automations/{automationId}/disable la disattiva (la mette in pausa). Le esecuzioni già in corso vengono completate; non ne iniziano di nuove. La disabilitazione è sempre consentita.

Nessuna delle due chiamate richiede un corpo.

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"},
)

Risposta (200): l’automazione così come è memorizzata ora, nella stessa struttura di una creazione, con draft: false dopo un’abilitazione.

Cronologia delle esecuzioni #

GET /automations/{automationId}/runs restituisce le esecuzioni di un’automazione, dalla più recente alla meno recente: quando ogni esecuzione è iniziata e terminata, cosa l’ha attivata, se ha avuto successo e l’errore in caso di fallimento. Leggere l’automazione ti dice cosa farebbe. La cronologia delle esecuzioni ti dice cosa ha fatto, ed è l’unico modo per distinguere un’automazione che non è mai stata eseguita da una che viene eseguita e fallisce ogni volta.

Parametri di query (tutti facoltativi): limit (da 1 a 50, predefinito 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"]

Risposta (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 è live per un’esecuzione reale, o safe per un’esecuzione sicura dall’editor. Un’esecuzione sicura non invia nulla, quindi non è una prova che l’automazione funzioni nell’uso reale.
• Un elenco runs vuoto è una risposta valida, non una mancanza. La risposta contiene quindi un note: significa che il trigger non è mai stato attivato o che l’automazione è spenta, quindi non è stato eseguito nulla.

Cartelle #

Le cartelle raggruppano solo le automazioni nell’elenco. Non cambiano mai ciò che fa un’automazione o se è attiva. Vedi Organizzare le automazioni nelle cartelle.

Elenca cartelle #

GET /automations/folders restituisce le cartelle, ognuna con il numero di automazioni che contiene, più unfiled_count: quante automazioni non sono in nessuna cartella.

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
}

Crea una cartella #

POST /automations/folders con { "name": "Appointment reminders" }. Il nome è obbligatorio, fino a 100 caratteri, e deve essere univoco nell’account. Inserisci le automazioni al suo interno con Sposta un’automazione, oppure passa folder_id quando ne crei una.

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

Risposta (201): { "success": true, "folder": { "id": "...", "name": "Appointment reminders", "automation_count": 0 } }. Un nome già utilizzato da un’altra cartella restituisce 409 con code: "folder_name_taken".

Rinomina una cartella #

PUT /automations/folders/{folderId} con { "name": "..." }. Le automazioni al suo interno rimangono dove sono.

Risposta (200): { "success": true, "folder": { ... } }.

Elimina una cartella #

DELETE /automations/folders/{folderId} elimina solo la cartella. Le automazioni al suo interno non vengono eliminate: vengono spostate fuori da qualsiasi cartella e continuano a funzionare esattamente come prima.

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

Spostare un’automazione in una cartella #

PUT /automations/{automationId}/folder con { "folder_id": "<folder id>" }, oppure { "folder_id": null } per rimuoverla dalla sua cartella. folder_id è obbligatorio. Cambia solo l’elenco in cui compare l’automazione.

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

Risposta (200): { "success": true, "automation_id": "...", "folder_id": "..." }.

Catalogo #

Tipi di passaggio #

Trigger #

Questi sono i 40 trigger elencati oggi nel catalogo, raggruppati come nel builder. La colonna Impostazioni contiene le chiavi di impostazione specifiche del trigger (fields), che ne restringono le condizioni di attivazione. Ogni trigger accetta anche respect_quiet_hours, run_hours, reentry e stop_on_response; vedi Impostazioni automazione.

Messaggistica

Contatti

Trattative

Appuntamenti

Attività

Account

Agenzia

Generale e app

Un’automazione può contenere al massimo un trigger per ciascuno di webhook, app_event, agent_function, rss, schedule, email_received, appointment_upcoming e contact_added. Un trigger che si attiva quando viene creato un record non può essere abbinato all’azione che crea lo stesso record, perché l’automazione innescherebbe se stessa.

Per sapere cosa trasmette ogni trigger ai passaggi successivi (output_keys) e per l’elenco completo delle azioni con i relativi parametri, leggi GET /automations/steps. La Guida alle automazioni spiega ogni trigger con le parole del builder.

Errori #

Ogni errore ha la solita forma { "success": false, "error_code": <status>, "error": "..." }. Un grafo rifiutato aggiunge code e 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 elenca ogni problema, con una frase risolutiva per ciascuno, e error è il primo. Correggi esattamente ciò che è elencato e invia nuovamente l’intero grafo. code è uno tra invalid_graph, automation_graph_has_a_cycle, self_triggering_automation, no_trigger o un altro codice del builder.

Passaggi successivi #

• Automazioni: come funzionano trigger, passaggi, variabili e cronologia delle esecuzioni nel builder.
• API per Agenzie: crea automazioni su un account cliente con sub_account_id.
• Riferimento API: l’esploratore interattivo completo degli endpoint.