Outbound Webhook Step

The Outbound Webhook step sends an HTTP request to an external endpoint during a workflow. Use it to push data to a third-party API, trigger actions in other systems, or upload files. When waitForResponse is enabled, the step can expose response fields for mapping in later steps.

For the mapping placeholder syntax, see Mapping.

Configuration

name	type	required	description
`request`	object	yes	The HTTP request to send. See Request below.
`waitForResponse`	boolean	no	When `true`, the workflow waits for the HTTP response before continuing. Default: `false`.
`continueOnError`	boolean	no	When `true`, the workflow continues even if the external service returns an error. Default: `false`.
`listeningModeEnabled`	boolean	no	When `true`, exposes `mappableFields` for downstream mapping. Default: `false`.
`requestPayload`	string	no	Example request payload for design-time documentation. Default: empty string.
`responsePayload`	string	no	Example response payload for design-time documentation. Default: empty string.
`mappableFields`	array	no	Fields extracted from the response that can be mapped in later steps. Default: empty array.

Request

The request object defines the HTTP call to make.

name	type	required	description
`method`	string	yes	HTTP method: `GET`, `POST`, `PUT`, or `DELETE`.
`url`	string	yes	The endpoint URL. Supports path placeholders like `:userId`.
`authentication`	object	yes	Authentication settings. See Authentication below.
`pathParams`	array	no	Path parameter substitutions. Each item has `key` and `value` (supports mapping).
`queryParams`	array	no	Query string parameters. Each item has `key` and `value` (supports mapping).
`headers`	array	no	Custom HTTP headers. Each item has `key` and `value` (supports mapping).
`body`	object	varies	Request body. See Body modes below. Required for POST and PUT; optional for DELETE; not allowed for GET.

Authentication

name	type	required	description
`type`	string	yes	`NONE` (no authentication) or `AUTHENTICATED` (uses a stored connection).
`connectionId`	string	yes	Reference to a stored connection. Set to `null` when `type` is `NONE`.

Body modes

The request body format is determined by the requestMode field.

RAW

Send raw content as JSON or plain text. String values support mapping placeholders.

name	type	required	description
`requestMode`	string	yes	Must be `RAW`.
`contentType`	string	yes	`JSON` or `TEXT`.
`content`	string or object	no	The body content. When `contentType` is `JSON`, can be a string or a JSON object with mapping-supported string values.

MULTIPART

Send form data as multipart content. Useful for forms with mixed text and file fields.

name	type	required	description
`requestMode`	string	yes	Must be `MULTIPART`.
`content`	array	yes	Key-value pairs for form fields. Each item has `key` and `value` (supports mapping).

RAW_BINARY

Send a file as the raw request body. The file can be a static reference or a mapping placeholder.

name	type	required	description
`requestMode`	string	yes	Must be `RAW_BINARY`.
`rawBinaryFile`	varies	yes	A file object or a mapping placeholder (e.g. `{{`Form`.`uploadedDocument`}}`). See File object below.

File object

Use a file object when referencing a specific file by ID or download URL (rather than a mapping placeholder).

name	type	required	description
`id`	string	yes (variant A)	File identifier. Use either `id` or `downloadUrl`, not both.
`downloadUrl`	string	yes (variant B)	File download URL. Use either `id` or `downloadUrl`, not both.
`name`	string	yes	File name.
`metadata`	object	no	Optional file metadata: `contentType`, `size`, `createdAt`, `updatedAt`.

Mappable fields

When listeningModeEnabled is true, you can define fields from the response that become available for mapping in later steps.

name	type	required	description
`key`	string	yes	Field key as it appears in the response JSON.
`label`	string	yes	Human-readable label (used in the UI).
`type`	string	yes	Data type (e.g. `string`, `number`, `boolean`).
`exampleValue`	varies	no	Example value for design-time documentation and testing.

Examples

Let's start with the simplest case: a GET request with no authentication or body.

{
  "request": {
    "method": "GET",
    "url": "https://api.example.com/users",
    "authentication": { "type": "NONE", "connectionId": null }
  }
}

Here's a POST request with a raw JSON body.

{
  "request": {
    "method": "POST",
    "url": "https://api.example.com/webhook",
    "authentication": { "type": "NONE", "connectionId": null },
    "body": {
      "requestMode": "RAW",
      "contentType": "JSON",
      "content": "{\"message\": \"Hello\"}"
    }
  }
}

Building on that, here's a full POST example with an authenticated connection, path and query parameters, a JSON object body with mapping placeholders, and response fields exposed for downstream mapping.

{
  "request": {
    "method": "POST",
    "url": "https://api.example.com/users/:userId",
    "authentication": { "type": "AUTHENTICATED", "connectionId": "my-api-connection" },
    "pathParams": [
      { "key": "userId", "value": "{{`Form`.`userId`}}" }
    ],
    "queryParams": [
      { "key": "format", "value": "json" }
    ],
    "headers": [
      { "key": "X-Custom-Header", "value": "custom-value" }
    ],
    "body": {
      "requestMode": "RAW",
      "contentType": "JSON",
      "content": {
        "name": "{{`Form`.`userName`}}",
        "email": "{{`Form`.`userEmail`}}",
        "metadata": {
          "source": "workflow",
          "requestId": "{{`Form`.`requestId`}}"
        }
      }
    }
  },
  "waitForResponse": true,
  "listeningModeEnabled": true,
  "mappableFields": [
    { "key": "id", "label": "User ID", "type": "string", "exampleValue": "usr-12345" },
    { "key": "status", "label": "Status", "type": "string", "exampleValue": "created" }
  ]
}

Here's a multipart request—useful for submitting form data alongside a file.

{
  "request": {
    "method": "POST",
    "url": "https://api.example.com/submit",
    "authentication": { "type": "NONE", "connectionId": null },
    "body": {
      "requestMode": "MULTIPART",
      "content": [
        { "key": "name", "value": "{{`Form`.`userName`}}" },
        { "key": "description", "value": "Static description" }
      ]
    }
  }
}

To upload a file as the raw body, use RAW_BINARY. You can reference a file by object or use a mapping placeholder.

{
  "request": {
    "method": "POST",
    "url": "https://api.example.com/upload",
    "authentication": { "type": "AUTHENTICATED", "connectionId": "file-api" },
    "body": {
      "requestMode": "RAW_BINARY",
      "rawBinaryFile": {
        "id": "file-123",
        "name": "document.pdf",
        "metadata": {
          "contentType": "application/pdf",
          "size": 1024000
        }
      }
    }
  }
}

{
  "request": {
    "method": "PUT",
    "url": "https://api.example.com/files",
    "authentication": { "type": "NONE", "connectionId": null },
    "body": {
      "requestMode": "RAW_BINARY",
      "rawBinaryFile": "{{`Form`.`uploadedDocument`}}"
    }
  }
}

Finally, here's a DELETE request with an optional body.

{
  "request": {
    "method": "DELETE",
    "url": "https://api.example.com/resources/:resourceId",
    "authentication": { "type": "AUTHENTICATED", "connectionId": "api-connection" },
    "pathParams": [
      { "key": "resourceId", "value": "{{`Form`.`resourceId`}}" }
    ],
    "body": {
      "requestMode": "RAW",
      "contentType": "JSON",
      "content": "{\"reason\": \"cleanup\"}"
    }
  }
}