# List Actions for an Agent

GET https://services.leadconnectorhq.com/conversation-ai/agents/{agentId}/actions/list

Deprecated — use GET /conversation-ai/agents/{agentId}/actions instead. List for actions for an agent, including any `customApi` ("API Call") actions.

## Authentication

Send `Authorization: Bearer <token>` using:

- **Sub-Account token: OAuth access token or Private Integration Token.** Scopes: `conversation-ai.readonly`

## Parameters

### Header Parameters

| Name | Type | Required | Description |
|------|------|----------|-------------|
| `Version` | string | Yes | API Version |

### Path Parameters

| Name | Type | Required | Description |
|------|------|----------|-------------|
| `agentId` | string | Yes | The unique identifier of the AI agent |

## OpenAPI Specification

```json
{
  "openapi": "3.0.0",
  "info": {
    "title": "LeadConnector API",
    "version": "v3"
  },
  "servers": [
    {
      "url": "https://services.leadconnectorhq.com"
    }
  ],
  "paths": {
    "/conversation-ai/agents/{agentId}/actions/list": {
      "get": {
        "summary": "List Actions for an Agent",
        "operationId": "listActionsForAnAgent",
        "description": "Deprecated — use GET /conversation-ai/agents/{agentId}/actions instead. List for actions for an agent, including any `customApi` (\"API Call\") actions.",
        "parameters": [
          {
            "name": "Version",
            "in": "header",
            "description": "API Version",
            "required": true,
            "schema": {
              "type": "string",
              "enum": [
                "v3"
              ]
            }
          },
          {
            "name": "agentId",
            "required": true,
            "in": "path",
            "description": "The unique identifier of the AI agent",
            "schema": {
              "example": "ve9EPM428h8vShlRW1KT",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/fetchActionsForEmployeeResponseDTO"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BadRequestDTO"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UnauthorizedDTO"
                }
              }
            }
          },
          "422": {
            "description": "Unprocessable Entity",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UnprocessableDTO"
                }
              }
            }
          }
        },
        "security": [
          {
            "bearer": [
              "conversation-ai.readonly"
            ]
          }
        ]
      }
    }
  },
  "components": {
    "securitySchemes": {
      "bearer": {
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "name": "Authorization",
        "in": "header",
        "description": "Use the Access Token generated with user type as Sub-Account (OR) Private Integration Token of Sub-Account.",
        "type": "http"
      },
      "Location-Access": {
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "name": "Authorization",
        "in": "header",
        "description": "Use the Access Token generated with user type as Sub-Account (OR) Private Integration Token of Sub-Account.",
        "type": "http"
      },
      "Location-Access-Only": {
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "name": "Authorization",
        "in": "header",
        "description": "Use the Access Token generated with user type as Sub-Account.",
        "type": "http"
      },
      "Agency-Access": {
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "name": "Authorization",
        "in": "header",
        "description": "Use the Access Token generated with user type as Agency (OR) Private Integration Token of Agency.",
        "type": "http"
      },
      "Agency-Access-Only": {
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "name": "Authorization",
        "in": "header",
        "description": "Use the Access Token generated with user type as Agency.",
        "type": "http"
      }
    },
    "schemas": {
      "fetchActionsForEmployeeResponseDTO": {
        "type": "object",
        "properties": {
          "data": {
            "type": "array",
            "description": "Actions for the agent — classic actions and customApi (API Call) actions",
            "items": {
              "oneOf": [
                {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string",
                      "example": "actionId123",
                      "description": "Unique identifier for the action"
                    },
                    "name": {
                      "type": "string",
                      "example": "Trigger Workflow",
                      "description": "Name of the action"
                    },
                    "type": {
                      "type": "string",
                      "enum": [
                        "triggerWorkflow",
                        "updateContactField",
                        "appointmentBooking",
                        "stopBot",
                        "humanHandOver",
                        "advancedFollowup",
                        "transferBot",
                        "customApi"
                      ],
                      "example": "triggerWorkflow",
                      "description": "Type of the action"
                    },
                    "agentId": {
                      "type": "string",
                      "example": "agentId123",
                      "description": "Agent ID where the action belongs"
                    },
                    "details": {
                      "description": "Action-specific details. The structure depends on the action type. For TRIGGER_WORKFLOW use triggerWorkflowDto, for UPDATE_CONTACT_FIELD use updateContactFieldDto, for APPOINTMENT_BOOKING use appointmentBookingDto, for STOP_BOT use stopBotDto, for HUMAN_HAND_OVER use humanHandOverDto, for ADVANCED_FOLLOWUP use advancedFollowupDto, and for TRANSFER_BOT use transferBotDto.",
                      "example": {
                        "workflowIds": [
                          "workflow123"
                        ],
                        "triggerCondition": "When user requests appointment"
                      },
                      "oneOf": [
                        {
                          "type": "object",
                          "properties": {
                            "workflowIds": {
                              "example": [
                                "workflow123",
                                "workflow456"
                              ],
                              "description": "Array of workflow IDs to trigger",
                              "type": "array",
                              "items": {
                                "type": "string"
                              }
                            },
                            "triggerCondition": {
                              "type": "string",
                              "example": "When user requests appointment",
                              "description": "Condition that triggers the workflow"
                            },
                            "triggerMessage": {
                              "type": "string",
                              "example": "Workflow triggered successfully",
                              "description": "Optional message to send when triggering the workflow"
                            }
                          },
                          "required": [
                            "workflowIds",
                            "triggerCondition"
                          ],
                          "title": "triggerWorkflowDto"
                        },
                        {
                          "type": "object",
                          "properties": {
                            "contactFieldId": {
                              "type": "string",
                              "example": "123",
                              "description": "ID of the contact field in Contacts Table"
                            },
                            "description": {
                              "type": "string",
                              "example": "Business Name",
                              "description": "Description of the contact field in Contacts Table"
                            },
                            "contactUpdateExamples": {
                              "example": [
                                "Example 1"
                              ],
                              "default": [],
                              "description": "Contact update examples in Contacts Table. Not required when using standard fields, Monetory or Date Custom fields.",
                              "type": "array",
                              "items": {
                                "type": "string"
                              }
                            }
                          },
                          "required": [
                            "contactFieldId",
                            "description"
                          ],
                          "title": "updateContactFieldDto"
                        },
                        {
                          "type": "object",
                          "properties": {
                            "actionId": {
                              "type": "string",
                              "example": "action123",
                              "description": "Optional action ID reference"
                            },
                            "calendarId": {
                              "type": "string",
                              "example": "calendar123",
                              "description": "Calendar ID for appointment booking"
                            },
                            "onlySendLink": {
                              "type": "boolean",
                              "example": false,
                              "description": "If true, only sends the appointment link without booking"
                            },
                            "triggerWorkflow": {
                              "type": "boolean",
                              "example": true,
                              "description": "Whether to trigger a workflow after booking (cannot be true when onlySendLink is true)"
                            },
                            "workflowIds": {
                              "example": [
                                "workflow123"
                              ],
                              "description": "Workflow IDs to trigger after booking (required when triggerWorkflow is true)",
                              "type": "array",
                              "items": {
                                "type": "string"
                              }
                            },
                            "sleepAfterBooking": {
                              "type": "boolean",
                              "example": true,
                              "description": "Whether to put the agent to sleep after booking (cannot be true when onlySendLink is true)"
                            },
                            "sleepTimeUnit": {
                              "type": "string",
                              "enum": [
                                "days",
                                "hours",
                                "minutes"
                              ],
                              "example": "hours",
                              "description": "Unit for sleep time (required when sleepAfterBooking is true)"
                            },
                            "sleepTime": {
                              "type": "number",
                              "example": 24,
                              "description": "Sleep duration (required when sleepAfterBooking is true)"
                            },
                            "transferBot": {
                              "type": "boolean",
                              "example": false,
                              "description": "Whether to transfer to another agent after booking (cannot be true when onlySendLink is true)"
                            },
                            "transferAgent": {
                              "type": "string",
                              "example": "employee456",
                              "description": "Agent ID to transfer to (required when transferBot is true)"
                            },
                            "rescheduleEnabled": {
                              "type": "boolean",
                              "default": false,
                              "example": true,
                              "description": "Whether to allow appointment rescheduling (cannot be true when onlySendLink is true)"
                            },
                            "cancelEnabled": {
                              "type": "boolean",
                              "default": false,
                              "example": true,
                              "description": "Whether to allow appointment cancellation (cannot be true when onlySendLink is true)"
                            }
                          },
                          "required": [
                            "calendarId",
                            "onlySendLink",
                            "triggerWorkflow",
                            "sleepAfterBooking",
                            "transferBot",
                            "rescheduleEnabled",
                            "cancelEnabled"
                          ],
                          "title": "appointmentBookingDto"
                        },
                        {
                          "type": "object",
                          "properties": {
                            "stopBotDetectionType": {
                              "type": "string",
                              "enum": [
                                "Goodbye",
                                "Custom"
                              ],
                              "example": "Custom",
                              "description": "Type of stop bot detection - Goodbye or Custom"
                            },
                            "stopBotTriggerCondition": {
                              "type": "string",
                              "example": "When the user says they no longer need assistance or want to end the conversation",
                              "description": "Condition that triggers stopping the bot"
                            },
                            "reactivateEnabled": {
                              "type": "boolean",
                              "example": true,
                              "description": "Whether the bot can be reactivated after being stopped"
                            },
                            "sleepTimeUnit": {
                              "type": "string",
                              "enum": [
                                "days",
                                "hours",
                                "minutes"
                              ],
                              "example": "hours",
                              "description": "Time unit for reactivation delay (required when reactivateEnabled is true)"
                            },
                            "sleepTime": {
                              "type": "number",
                              "example": 24,
                              "description": "Time duration before reactivation (required when reactivateEnabled is true)"
                            },
                            "enabled": {
                              "type": "boolean",
                              "example": true,
                              "description": "Whether this action is enabled for the agent"
                            },
                            "stopBotExamples": {
                              "example": [
                                "goodbye",
                                "thank you",
                                "no more questions"
                              ],
                              "description": "Example phrases that trigger stop bot action (minimum 2 required)",
                              "type": "array",
                              "items": {
                                "type": "string"
                              }
                            },
                            "finalMessage": {
                              "type": "string",
                              "example": "Thank you for contacting us. Have a great day!",
                              "description": "Final message sent when stopping the bot"
                            },
                            "tags": {
                              "example": [
                                "resolved",
                                "no-response"
                              ],
                              "description": "Tags to apply when stopping the bot",
                              "type": "array",
                              "items": {
                                "type": "string"
                              }
                            }
                          },
                          "required": [
                            "stopBotDetectionType",
                            "stopBotTriggerCondition",
                            "reactivateEnabled",
                            "enabled",
                            "stopBotExamples",
                            "finalMessage"
                          ],
                          "title": "stopBotDto"
                        },
                        {
                          "type": "object",
                          "properties": {
                            "enabled": {
                              "type": "boolean",
                              "example": true,
                              "description": "Whether human handover action is enabled"
                            },
                            "triggerCondition": {
                              "type": "string",
                              "example": "When the user requests to speak with a human agent or expresses frustration",
                              "description": "Condition that triggers human handover"
                            },
                            "examples": {
                              "example": [
                                "speak to human",
                                "talk to agent",
                                "need help from person"
                              ],
                              "description": "Example phrases that trigger human handover (required when handoverType is custom or contactRequest)",
                              "type": "array",
                              "items": {
                                "type": "string"
                              }
                            },
                            "assignToUserId": {
                              "type": "string",
                              "example": "user123",
                              "description": "ID of the user to assign the conversation to"
                            },
                            "skipAssignToUser": {
                              "type": "boolean",
                              "example": false,
                              "description": "Whether to skip assigning to a specific user"
                            },
                            "createTask": {
                              "type": "boolean",
                              "example": true,
                              "description": "Whether to create a task when handing over"
                            },
                            "reactivateEnabled": {
                              "type": "boolean",
                              "example": true,
                              "description": "Whether the agent can be reactivated after handover"
                            },
                            "sleepTimeUnit": {
                              "type": "string",
                              "enum": [
                                "days",
                                "hours",
                                "minutes"
                              ],
                              "example": "hours",
                              "description": "Time unit for reactivation delay (required when reactivateEnabled is true)"
                            },
                            "sleepTime": {
                              "type": "number",
                              "example": 24,
                              "description": "Time duration before reactivation (required when reactivateEnabled is true)"
                            },
                            "finalMessage": {
                              "type": "string",
                              "example": "I am transferring you to a human agent who will assist you shortly.",
                              "description": "Final message sent when handing over to human"
                            },
                            "tags": {
                              "example": [
                                "escalated",
                                "human-requested"
                              ],
                              "description": "Tags to apply during handover",
                              "type": "array",
                              "items": {
                                "type": "string"
                              }
                            },
                            "handoverType": {
                              "type": "string",
                              "enum": [
                                "contactRequest",
                                "lackOfInformation",
                                "failedToResolveIssue",
                                "custom"
                              ],
                              "example": "contactRequest",
                              "description": "Type of human handover detection"
                            }
                          },
                          "required": [
                            "enabled",
                            "triggerCondition",
                            "reactivateEnabled",
                            "finalMessage",
                            "handoverType"
                          ],
                          "title": "humanHandOverDto"
                        },
                        {
                          "type": "object",
                          "properties": {
                            "enabled": {
                              "type": "boolean",
                              "example": true,
                              "description": "Whether advanced followup is enabled"
                            },
                            "scenarioId": {
                              "type": "string",
                              "example": "contactIsBusy",
                              "enum": [
                                "contactStoppedReplying",
                                "contactIsBusy",
                                "contactRequested"
                              ],
                              "description": "ID of the followup scenario"
                            },
                            "followupSequence": {
                              "description": "Sequence of followup actions to perform",
                              "example": [
                                {
                                  "id": 1,
                                  "followupTimeUnit": "hours",
                                  "followupTime": 2,
                                  "aiEnabledMessage": true
                                }
                              ],
                              "type": "array",
                              "items": {
                                "type": "object",
                                "properties": {
                                  "id": {
                                    "type": "number",
                                    "example": 1,
                                    "description": "Unique identifier for this followup step"
                                  },
                                  "followupTimeUnit": {
                                    "type": "string",
                                    "enum": [
                                      "days",
                                      "hours",
                                      "minutes"
                                    ],
                                    "example": "hours",
                                    "description": "Time unit for followup delay"
                                  },
                                  "followupTime": {
                                    "type": "number",
                                    "example": 2,
                                    "description": "Time duration before followup (max: 60 minutes, 24 hours, or 180 days depending on unit)"
                                  },
                                  "aiEnabledMessage": {
                                    "type": "boolean",
                                    "example": true,
                                    "default": true,
                                    "description": "Whether to use AI to generate the followup message"
                                  },
                                  "triggerWorkflow": {
                                    "type": "boolean",
                                    "example": false,
                                    "default": false,
                                    "description": "Whether to trigger a workflow during this followup"
                                  },
                                  "customMessage": {
                                    "type": "string",
                                    "example": "Hi! Just following up on our previous conversation. Do you have any questions?",
                                    "description": "Custom message to send (when aiEnabledMessage is false)"
                                  },
                                  "workflowId": {
                                    "type": "string",
                                    "example": "workflow789",
                                    "description": "Workflow ID to trigger (when triggerWorkflow is true)"
                                  },
                                  "contactRequested": {
                                    "type": "boolean",
                                    "example": false,
                                    "description": "Whether contact was requested in this followup"
                                  }
                                },
                                "required": [
                                  "id",
                                  "followupTimeUnit",
                                  "followupTime"
                                ],
                                "title": "FollowupSequence"
                              }
                            },
                            "followupSettings": {
                              "description": "Additional settings for followup behavior",
                              "example": {
                                "dynamicChannelSwitching": true,
                                "followUpHours": false,
                                "timezoneToUse": "contact"
                              },
                              "allOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "dynamicChannelSwitching": {
                                      "type": "boolean",
                                      "example": true,
                                      "default": true,
                                      "description": "Whether to dynamically switch channels for followups"
                                    },
                                    "followUpHours": {
                                      "type": "boolean",
                                      "example": true,
                                      "description": "Whether to respect working hours for followups"
                                    },
                                    "workingHours": {
                                      "description": "Working hours configuration for followups",
                                      "example": [
                                        {
                                          "dayOfTheWeek": 1,
                                          "intervals": [
                                            {
                                              "startHour": 9,
                                              "startMinute": 0,
                                              "endHour": 17,
                                              "endMinute": 0
                                            }
                                          ]
                                        }
                                      ],
                                      "type": "array",
                                      "items": {
                                        "type": "object",
                                        "properties": {
                                          "dayOfTheWeek": {
                                            "type": "number",
                                            "example": 1,
                                            "description": "Day of the week (0=Sunday, 1=Monday, etc.)"
                                          },
                                          "intervals": {
                                            "description": "Time intervals for this day",
                                            "example": [
                                              {
                                                "startHour": 9,
                                                "startMinute": 0,
                                                "endHour": 17,
                                                "endMinute": 0
                                              }
                                            ],
                                            "type": "array",
                                            "items": {
                                              "type": "object",
                                              "properties": {
                                                "startHour": {
                                                  "type": "number",
                                                  "example": 9,
                                                  "description": "Start hour (24-hour format)"
                                                },
                                                "startMinute": {
                                                  "type": "number",
                                                  "example": 0,
                                                  "description": "Start minute"
                                                },
                                                "endHour": {
                                                  "type": "number",
                                                  "example": 17,
                                                  "description": "End hour (24-hour format)"
                                                },
                                                "endMinute": {
                                                  "type": "number",
                                                  "example": 30,
                                                  "description": "End minute"
                                                }
                                              },
                                              "required": [
                                                "startHour",
                                                "startMinute",
                                                "endHour",
                                                "endMinute"
                                              ],
                                              "title": "Interval"
                                            }
                                          }
                                        },
                                        "required": [
                                          "dayOfTheWeek"
                                        ],
                                        "title": "WorkingHours"
                                      }
                                    },
                                    "timezoneToUse": {
                                      "type": "string",
                                      "enum": [
                                        "contact",
                                        "business"
                                      ],
                                      "description": "Timezone to use for followups, contact or location",
                                      "example": "contact"
                                    }
                                  },
                                  "required": [
                                    "dynamicChannelSwitching"
                                  ],
                                  "title": "FollowupSettings"
                                }
                              ]
                            }
                          },
                          "required": [
                            "enabled",
                            "scenarioId",
                            "followupSequence"
                          ],
                          "title": "advancedFollowupDto"
                        },
                        {
                          "type": "object",
                          "properties": {
                            "transferBotType": {
                              "type": "string",
                              "enum": [
                                "Default",
                                "Custom"
                              ],
                              "example": "Custom",
                              "description": "Type of transfer - Default or Custom"
                            },
                            "transferToBot": {
                              "type": "string",
                              "example": "employee789",
                              "description": "ID of the bot/agent to transfer to"
                            },
                            "enabled": {
                              "type": "boolean",
                              "example": true,
                              "description": "Whether this transfer action is enabled"
                            },
                            "transferBotTriggerCondition": {
                              "type": "string",
                              "example": "When the user asks to speak with sales or needs pricing information",
                              "description": "Condition that triggers the transfer (required for Custom type)"
                            },
                            "transferBotExamples": {
                              "example": [
                                "talk to sales",
                                "pricing information",
                                "speak to specialist"
                              ],
                              "description": "Example phrases that trigger transfer (required for Custom type, minimum 2)",
                              "type": "array",
                              "items": {
                                "type": "string"
                              }
                            }
                          },
                          "required": [
                            "transferBotType",
                            "transferToBot",
                            "enabled"
                          ],
                          "title": "transferBotDto"
                        }
                      ]
                    }
                  },
                  "required": [
                    "id",
                    "name",
                    "type",
                    "details"
                  ],
                  "title": "ActionDataDTO"
                },
                {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string",
                      "example": "instanceId123",
                      "description": "Unique identifier for the API Call action"
                    },
                    "name": {
                      "type": "string",
                      "example": "Get Orders",
                      "description": "Name of the API Call action"
                    },
                    "type": {
                      "type": "string",
                      "enum": [
                        "customApi"
                      ],
                      "example": "customApi",
                      "description": "Always customApi"
                    },
                    "agentId": {
                      "type": "string",
                      "example": "agentId123",
                      "description": "Agent ID where the action belongs"
                    },
                    "details": {
                      "description": "API Call config — description, triggerCondition, and the HTTP definition (secrets redacted on read).",
                      "allOf": [
                        {
                          "type": "object",
                          "properties": {
                            "triggerCondition": {
                              "type": "string",
                              "maxLength": 500,
                              "description": "\"use this when…\" rule shown to the agent. REQUIRED on CREATE (enforced in the handler) to match the builder; on UPDATE it may be OMITTED to leave it unchanged, but sending it blank is rejected.",
                              "example": "When the customer asks where their order is or for a delivery date."
                            },
                            "description": {
                              "type": "string",
                              "maxLength": 2000,
                              "description": "Optional description of the API Call action",
                              "example": "Looks up an order in the fulfilment system and returns its status and delivery date."
                            },
                            "postActionPrompt": {
                              "type": "string",
                              "maxLength": 300,
                              "description": "Guidance the agent follows AFTER the call returns (e.g. how to phrase the reply, what not to reveal). REQUIRED on CREATE (enforced in the handler) to match the builder; on UPDATE it may be OMITTED to leave it unchanged (partial merge), but sending it blank is rejected."
                            },
                            "apiConfig": {
                              "description": "The self-contained HTTP definition. Required on CREATE (enforced in the handler). OPTIONAL on UPDATE — omit it to edit just name/description/triggerCondition. When sent on update it is merged ONE LEVEL DEEP over the stored config: top-level keys present replace the stored value, keys absent are kept, and nested objects/arrays (headers, queryParams, bodyTemplate, parameters, outputFields) are replaced whole — send the complete value, not just the entry that changed. Secrets are redacted on read; see `authentication` for how they round-trip.",
                              "allOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "url": {
                                      "type": "string",
                                      "example": "https://api.example.com/orders/{{orderId}}",
                                      "description": "HTTPS endpoint; supports {{var}}. REQUIRED on create. Optional on update — omit it to keep the stored url (apiConfig merges by top-level key)."
                                    },
                                    "method": {
                                      "type": "string",
                                      "enum": [
                                        "GET",
                                        "POST",
                                        "PUT",
                                        "PATCH",
                                        "DELETE"
                                      ],
                                      "example": "GET",
                                      "description": "HTTP method used for the call. REQUIRED on create. Optional on update — omit it to keep the stored method."
                                    },
                                    "headers": {
                                      "type": "object",
                                      "additionalProperties": {
                                        "type": "string"
                                      },
                                      "description": "Static HTTP headers sent with every call. Secrets belong in `authentication`, not here. On update this object REPLACES the stored headers — send them all, not just the changed one.",
                                      "example": {
                                        "Content-Type": "application/json",
                                        "X-Source": "conversation-ai"
                                      }
                                    },
                                    "queryParams": {
                                      "type": "object",
                                      "additionalProperties": {
                                        "type": "string"
                                      },
                                      "description": "Static query-string parameters appended to the URL.",
                                      "example": {
                                        "status": "active",
                                        "limit": "10"
                                      }
                                    },
                                    "bodyTemplate": {
                                      "type": "object",
                                      "description": "Request body template — object or raw JSON string. Supports {{variable}} placeholders.",
                                      "example": {
                                        "orderId": "{{parameters.orderId}}",
                                        "email": "{{contact.email}}"
                                      }
                                    },
                                    "parameters": {
                                      "type": "object",
                                      "additionalProperties": true,
                                      "description": "JSON Schema of LLM-supplied params",
                                      "example": {
                                        "type": "object",
                                        "properties": {
                                          "orderId": {
                                            "type": "string",
                                            "description": "The order number the caller gave"
                                          }
                                        },
                                        "required": [
                                          "orderId"
                                        ]
                                      }
                                    },
                                    "authentication": {
                                      "type": "object",
                                      "description": "Auth config; secrets stored per-instance, write-only",
                                      "example": {
                                        "type": "bearer",
                                        "token": "••••••••"
                                      }
                                    },
                                    "timeoutMs": {
                                      "type": "number",
                                      "example": 15000,
                                      "description": "Per-request timeout in milliseconds (max 60000)."
                                    },
                                    "retryOnFailure": {
                                      "type": "boolean",
                                      "example": false,
                                      "description": "Retry the call once on a network error or a 5xx. 4xx is never retried."
                                    },
                                    "useSimpleRequestBody": {
                                      "type": "boolean",
                                      "example": false,
                                      "description": "Send the body template verbatim as raw JSON instead of building it from the parameter schema."
                                    },
                                    "outputFields": {
                                      "example": [
                                        "data.id",
                                        "data.status"
                                      ],
                                      "description": "Dot-paths of the response fields handed back to the agent. Omit to return the whole body; use [] notation for arrays, e.g. `result[].id`.",
                                      "type": "array",
                                      "items": {
                                        "type": "string"
                                      }
                                    },
                                    "sampleResponse": {
                                      "type": "object",
                                      "additionalProperties": true,
                                      "description": "Trimmed sample of a real response (editor Test tab). Prompt-only — inlined so the agent knows the response shape; never executed. Secrets are masked on read."
                                    }
                                  },
                                  "title": "ApiCallConfigDTO"
                                }
                              ]
                            }
                          },
                          "title": "CustomApiDetailsDTO"
                        }
                      ]
                    }
                  },
                  "required": [
                    "id",
                    "name",
                    "type"
                  ],
                  "title": "CustomApiActionDataDTO"
                }
              ]
            },
            "example": [
              {
                "id": "actionId123",
                "name": "Trigger Workflow",
                "type": "triggerWorkflow"
              }
            ]
          },
          "success": {
            "type": "boolean",
            "example": true,
            "description": "Success status of the request"
          }
        },
        "required": [
          "data",
          "success"
        ],
        "title": "fetchActionsForEmployeeResponseDTO"
      },
      "BadRequestDTO": {
        "type": "object",
        "properties": {
          "statusCode": {
            "type": "number",
            "example": 400
          },
          "message": {
            "type": "string",
            "example": "Bad Request"
          }
        },
        "title": "BadRequestDTO"
      },
      "UnauthorizedDTO": {
        "type": "object",
        "properties": {
          "statusCode": {
            "type": "number",
            "example": 401
          },
          "message": {
            "type": "string",
            "example": "Invalid token: access token is invalid"
          },
          "error": {
            "type": "string",
            "example": "Unauthorized"
          }
        },
        "title": "UnauthorizedDTO"
      },
      "UnprocessableDTO": {
        "type": "object",
        "properties": {
          "statusCode": {
            "type": "number",
            "example": 422
          },
          "message": {
            "example": [
              "Unprocessable Entity"
            ],
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "error": {
            "type": "string",
            "example": "Unprocessable Entity"
          }
        },
        "title": "UnprocessableDTO"
      }
    }
  }
}
```

## Code Examples

**cURL**

```bash
curl -L -X GET 'https://services.leadconnectorhq.com/conversation-ai/agents/<agentId>/actions/list' \
  -H 'Authorization: Bearer <TOKEN>' \
  -H 'Version: v3'
```

**Node.js**

```javascript
const options = {
  method: 'GET',
  headers: {
    Authorization: 'Bearer <TOKEN>',
    Version: 'v3'
  }
};

try {
  const response = await fetch('https://services.leadconnectorhq.com/conversation-ai/agents/<agentId>/actions/list', options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

**Python**

```python
import requests

url = "https://services.leadconnectorhq.com/conversation-ai/agents/{agentId}/actions/list"

headers = {
    "Authorization": "Bearer <TOKEN>",
    "Version": "v3"
}

response = requests.get(url, headers=headers)
print(response.json())
```

**PHP**

```php
<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => 'https://services.leadconnectorhq.com/conversation-ai/agents/<agentId>/actions/list',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer <TOKEN>',
    'Version: v3',
  ],
]);

$response = curl_exec($curl);
curl_close($curl);
echo $response;
```

**Java**

```java
HttpResponse<String> response = Unirest
  .get("https://services.leadconnectorhq.com/conversation-ai/agents/<agentId>/actions/list")
  .header("Authorization", "Bearer <TOKEN>")
  .header("Version", "v3")
  .asString();
```

**Go**

```go
package main

import (
  "fmt"
  "net/http"
  "io"
)

func main() {
  url := "https://services.leadconnectorhq.com/conversation-ai/agents/<agentId>/actions/list"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <TOKEN>")
  req.Header.Add("Version", "v3")

  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := io.ReadAll(res.Body)
  fmt.Println(string(body))
}
```

**Ruby**

```ruby
require 'uri'
require 'net/http'

url = URI("https://services.leadconnectorhq.com/conversation-ai/agents/<agentId>/actions/list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer <TOKEN>"
request["Version"] = "v3"

response = http.request(request)
puts response.read_body
```

**PowerShell**

```powershell
$headers = @{
  "Authorization" = "Bearer <TOKEN>"
  "Version" = "v3"
}

$response = Invoke-RestMethod -Uri 'https://services.leadconnectorhq.com/conversation-ai/agents/<agentId>/actions/list' -Method 'GET' -Headers $headers
$response | ConvertTo-Json
```
