> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://api.logicdialog.ai/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://api.logicdialog.ai/_mcp/server.

# Workflows and events

Open **Workflows**, after Evaluation criteria, in a selected workstream. Create a workflow, choose its LogicDialog event, connect processing nodes and save. Review Before changes and After changes in Changes, then Apply to the destination environment. Saved drafts do not handle live events.

## Choose a trigger

The LogicDialog event node supports:

* Populate initial conversation data.
* Conversation started, ended, failed to start, or reported an error.
* Monitoring alert raised, resolved, or dismissed.
* Customer waiting and agent assigned.
* Content imported.
* Environment deployed and deployed to Live.

Event data enters the first node as `data`. The trusted `context.workspaceId` and `context.environment` identify which workspace and deployment handle the event. Assistant-wide monitoring alerts do not identify a source environment. See [Alerts and notifications](/integration-guides/alerts-and-notifications) for alert scope, fields and notification examples. To handle a particular named environment, branch on `context.environment` after an Environment deployed event.

Conversation started is emitted for conversations initiated through LogicDialog's native or asynchronous channels. Conversation ended arrives after the provider finishes post-conversation analysis.

## Return data

Connect an HTTP response node to return a JSON object. Initial-data workflows can return `dynamic_variables` and `user_id`. They cannot select another environment or change system variables. For example:

```json
{
  "dynamic_variables": {
    "greeting": "Welcome back",
    "customer_tier": "gold"
  }
}
```

Only one workflow may return a non-empty response to the same event. If nothing responds, the callback returns an empty object. A conversation-ended response acknowledges delivery; it does not change the completed conversation.

## Receive an external webhook

Add a Webhook trigger and configure its method and route. Open **External webhook details**, select the applied environment, and copy its base URL and token. Append the trigger's route to that URL and send the token in an `Authorization: Bearer` header. Keep the token private.

Incoming webhook data contains `body`, `query`, `method` and `path`. An unmatched route returns an empty object. Provider conversation callbacks are configured automatically when agents are applied.

## Test and operate

Preview runs execute the selected workstream definition. HTTP requests in a preview can call external services. Outbound HTTP nodes accept public HTTPS destinations.

Workflows have bounded execution times and run in the application process. Delays and unfinished runs do not survive a restart. Successful post-conversation deliveries are deduplicated, but a failed or interrupted workflow can repeat earlier actions on retry. Make external actions idempotent. Internal notifications are best-effort rather than a durable delivery queue.

## Configure a linked action

You can leave the external webhook route blank when only assistants will call the workflow.

In the workflow's Webhook trigger, enable **Available to assistants** and save. Open **Actions** and select the new linked entry. Configure its purpose, headers, inputs, response mappings and conversation behaviour there. LogicDialog supplies the endpoint, method and authentication automatically.

Inputs can come from the conversation, a fixed value or an existing conversation variable. The workflow receives body fields in `data.body`, query fields in `data.query`, path fields in `data.path`, and your configured ordinary headers in `data.headers`. Header names are lowercase. Authentication headers are never included in workflow data.

Use **Open workflow** to edit or preview the logic. An HTTP response node chooses the returned data; the Action can optionally validate the response fields and save values into conversation variables. Configure inputs and expected response fields in Actions.

Save the action, select it in routing, review the workstream and Apply. Deleting its Actions entry turns off assistant access while keeping the workflow. Remove routing references before applying that removal.

## Business integrations

Add an integration node to send a message, open a support ticket, save a lead or record, append to an existing Google document or spreadsheet, look up Redis data, or generate text with an AI model. The node's help describes its supported operation, required permissions and returned fields.

Choose **Add connection** to enter credentials. They are stored securely; only a connection reference is saved with the workflow. Replacing a connection takes effect after you save and apply the workflow. Access tokens must be replaced when they expire; this release does not include account sign-in or automatic token renewal.

Use references such as `{{data.body.email}}` in fields. For a spreadsheet row, enter a JSON array such as `["{{data.body.name}}", "{{data.body.email}}"]`. Each node stores its response under **Result field**, preserving the other data for later steps. For example, a Slack result stored as `slack` makes the sent message timestamp available as `{{data.slack.ts}}`.

Connect the **Error** output to handle unavailable services or rejected requests. Preview runs make real requests, including sending messages and creating records. Requests are not automatically retried; rerunning a flow can repeat these actions. An accepted email or SMS request does not confirm delivery.

### Reading existing records

Choose **Operation → Get** on a ticket, task, contact or data node to look up an existing record instead of creating one. Supply the ID returned by an earlier step or passed into the workflow. For example, Zendesk returns `ticket.status`, Freshdesk returns `status`, and Jira returns `fields.status.name` under your chosen Result field.

Google Sheets can read a range such as `Sheet1!A2:D2`. Supabase can look up one row by a unique column value; it returns an array, empty when no row matches. List operations in Notion, Google Calendar and Calendly return a next-page cursor when more results are available. An ID lookup returning HTTP 404 follows the Error output.

### Email templates and AI models

SendGrid, Mailgun, Brevo and Resend let you choose **Saved template** and provide its ID/name and a JSON object of template values. The provider template supplies the subject and content; Mailgun needs a Subject header saved on its template. Outlook continues to use a message composed from workflow fields because its send API does not take a saved-template ID.

For OpenAI, Anthropic or Fireworks.ai, save a connection, then open the **Model** list or select **Refresh models**. Model names come from the provider. Fireworks shows public serverless chat models. Reading the list does not run a model or change your selected model. Account access and the workflow's timeout still apply.

### Integration catalogue

| Area                    | Integrations                                                          |
| ----------------------- | --------------------------------------------------------------------- |
| Messaging               | Slack, Microsoft Teams, Twilio SMS, Discord, Telegram                 |
| Email                   | SendGrid, Mailgun, Outlook, Brevo, Resend                             |
| Support                 | Zendesk, Freshdesk, Intercom, Help Scout, Freshservice                |
| Tasks                   | Jira, Linear, GitHub, GitLab, Trello, Asana, ClickUp, monday.com      |
| CRM                     | HubSpot, Salesforce, Pipedrive, Zoho CRM                              |
| Documents and databases | Google Sheets, Google Docs, Airtable, Supabase, Upstash Redis, Notion |
| Commerce                | Stripe, Shopify, WooCommerce                                          |
| Scheduling              | Google Calendar, Calendly, Zoom                                       |
| AI                      | OpenAI, Anthropic, Fireworks.ai                                       |

## Outbound calls and SMS from another system

Create a client in **Channels → API integrations**, generate and copy its API token, and select each allowed workflow by name under **Allowed outbound schedules**. The picker lists applied call and SMS schedules for the selected environment, including paused timers. API requests still use the workflow ID and its outbound trigger node ID. An empty list grants no outbound access. For an outbound-only client, clear **Allowed message channels**; no reply webhook, webhook signing secret or asynchronous messaging connection is required. Enable the outbound-only client and apply the configuration to the same environment as its schedule (for example Development or Live). Set the API request environment to match. Keep the API token on your server, never in browser code.

The schedule chooses voice or Twilio SMS, the assistant and the sending number. Use an applied workflow; for scheduled contacts, enable its timer and have its recipient workflow return `{ "recipients": [] }`. This selects queued contacts when the workflow checks. A nonempty recipient list takes priority over queued contacts, so use a dedicated contact-list workflow for predictable scheduling.

Submit an immediate callback:

```bash
curl --request POST \
  'https://app.logicdialog.ai/outbound/contacts?workspaceId=halo&environment=live&integrationId=crm' \
  --header "Authorization: Bearer $LOGICDIALOG_API_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{
    "id": "callback-123",
    "flowId": "callback-flow",
    "nodeId": "outbound-trigger",
    "userId": "+447700900123",
    "variables": { "name": "Alex" },
    "runNow": true
  }'
```

Replace the example client/workflow/trigger IDs with your configured values. `userId` is the destination phone number. Supply the initial variables required by your assistant; `ld_` names are reserved. The same endpoint handles voice and SMS according to the chosen schedule.

Outbound calls merge the deployed workspace's dynamic-variable defaults with the submitted variables; submitted values take precedence. Changes to defaults require applying the environment again. This lets routing **Set State** nodes populate greeting and voicemail text from a selector such as `call_type`, without sending message text from the calling application. Leave the assistant's First message empty when a routing **Say** node provides the greeting after state has been set.

A voicemail message may be a single variable reference such as `{{voicemail_message}}`. Initialise it in every applicable routing path before voicemail detection, and put the full message text in Set State. The schedule cannot check the eventual length of a variable-only message; use at least 100 characters of actual text. Literal messages still require 100 characters excluding placeholders and markup.

For a future contact, replace `runNow` with `scheduledAt`, for example `"2026-12-01T10:00:00Z"`. The timestamp must be in the future, include a timezone and fall within the next year. Omitting both fields makes the contact due at the next eligible check. This is a not-before time, not a guaranteed delivery time: workflow intervals, contact days/hours and available capacity still apply.

`runNow: true` attempts only the submitted contact without fetching a recipient list. It can run with the timer paused but still respects contact hours and concurrency. A new contact returns HTTP 201; a repeated ID returns 200. Always inspect `status` and `deferredReason`: accepting a contact into storage does not mean it was dialled. When deferred, retry with the same ID and `runNow: true`, or let an enabled contact-list workflow pick it up. A paused timer will not pick it up automatically. A successful submission does not enable that timer.

Reuse the same ID and payload when retrying after timeouts. An ID is scoped to the client, workspace, environment and schedule. Repeating it does not update its original recipient, variables or time, or redial a submitted contact. Receipts protect against duplicates for 30 days; use a new ID for each new intended contact and never replay old requests beyond retention.

Read its current state using the same API token:

```text
GET /outbound/contacts/callback-123?workspaceId=halo&environment=live&integrationId=crm&flowId=callback-flow&nodeId=outbound-trigger
```

Status reports delivery progress, not whether a person answered or the objective succeeded. Unknown contacts, contacts belonging to another client and expired records return 404. These endpoints require the outbound worker and existing outbound queue migrations. They do not expose transcripts or audio.