Automation Examples

Examples of DocStudio Automations that notify chat services and approve vacation requests.

The following examples demonstrate how multiple automation types can be combined into workflows for common integration and business-process scenarios.

Send a Chat Notification When an Envelope Is Completed

This example sends a notification when an envelope reaches the COMPLETED status. The workflow detects the envelope, builds a JSON message, and sends it through an HTTP request.

The workflow uses the following automation types:

Build the notification message

The xslt-converter transforms envelope.xml into the JSON body sent to the external service. The following XSLT creates a Google Chat message containing the envelope subject and status:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:template match="/envelope">
    <xsl:text>{"text": "Envelope \"</xsl:text>
    <xsl:value-of select="info/subject"/>
    <xsl:text>\" is now </xsl:text>
    <xsl:value-of select="state/status"/>
    <xsl:text>"}</xsl:text>
  </xsl:template>
</xsl:stylesheet>

The generated Google Chat message has the following format:

{
  "text": "Envelope \"000\" is now COMPLETED"
}

Configure the target service

Use a Google Chat incoming-webhook URL with the Google Chat message above.

For Telegram, use the sendMessage endpoint and include the target chat_id:

<xsl:text>{"chat_id": "-100123456789", "text": "Envelope \"</xsl:text>
<xsl:value-of select="info/subject"/>
<xsl:text>\" is now </xsl:text>
<xsl:value-of select="state/status"/>
<xsl:text>"}</xsl:text>

Use the Telegram API URL in this format:

https://api.telegram.org/bot<bot-token>/sendMessage

Webhook URLs and Telegram bot tokens are secrets. Do not commit production values or include them in shared automation payloads.

Automation payload

{
  "name": "Notify chat on envelope completion",
  "active": true,
  "workflow": [
    {
      "id": "11111111-1111-1111-1111-111111111111",
      "type": "envelope-trigger",
      "description": "Catch completed envelopes",
      "config": {
        "status": [
          "COMPLETED"
        ]
      },
      "next": [
        "44444444-4444-4444-4444-444444444444"
      ]
    },
    {
      "id": "44444444-4444-4444-4444-444444444444",
      "type": "xslt-converter",
      "description": "Build chat message JSON from envelope fields",
      "config": {
        "filename": "message.json",
        "map": "<?xml version=\"1.0\" encoding=\"UTF-8\"?><xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\"><xsl:output method=\"text\"/><xsl:template match=\"/envelope\"><xsl:text>{\"text\": \"Envelope \\\"</xsl:text><xsl:value-of select=\"info/subject\"/><xsl:text>\\\" is now </xsl:text><xsl:value-of select=\"state/status\"/><xsl:text>\"}</xsl:text></xsl:template></xsl:stylesheet>"
      },
      "next": [
        "22222222-2222-2222-2222-222222222222"
      ]
    },
    {
      "id": "22222222-2222-2222-2222-222222222222",
      "type": "api-caller",
      "description": "POST to Google Chat / Telegram",
      "config": {
        "url": "<google-chat-webhook-url-or-telegram-sendMessage-url>",
        "method": "post",
        "contentType": "application/json",
        "timeout": 5000,
        "retries": 3,
        "successCode": 200
      },
      "next": []
    }
  ]
}

Set contentType to application/json. The request then uses the expected content type. For Telegram, use the Telegram URL and XSLT shown above.

Verify the notification

Complete an envelope that matches the trigger. Then retrieve the execution and confirm its state is SUCCEED.

If the request fails, retrieve the execution log. Check the api-caller operation for the response from the chat service.

Auto-Approve or Reject a Vacation Request Based on an External Balance

This example checks an employee's available vacation balance using an external REST API. When a vacation request reaches the approver's mailbox, the automation retrieves the available balance, compares it with the requested number of days, and automatically approves or rejects the request.

The workflow uses the following automation types:

Build the balance request

The xslt-converter creates the request body for the external service using values from the vacation request envelope. The exact XPath expressions depend on how the required fields are represented in envelope.xml.

The resulting request must contain the information required by the external service to identify the employee and determine the requested number of vacation days.

Check the vacation balance

The api-caller sends the generated request to the external HR or leave-management API:

{
  "url": "https://hr.example.com/api/vacation-balance",
  "method": "post",
  "contentType": "application/json",
  "filename": "balance-response.json"
}

The response must provide both the available vacation balance and the requested number of days so that the following conditions can evaluate the result.

Approve or reject the request

Two if-condition operations process the API response. Both are direct children of api-caller.

The first condition checks whether the available balance is sufficient:

{
  "executor": "jsonpath",
  "expression": "$[?(@.balance >= @.requested)]"
}

When this condition matches, the workflow continues to envelope-approver, which approves the pending request:

{
  "id": "approve",
  "type": "envelope-approver",
  "description": "Sufficient balance — approve on behalf of this approver mailbox, sending the envelope forward",
  "config": {},
  "next": []
}

The second condition checks the opposite case:

{
  "executor": "jsonpath",
  "expression": "$[?(@.balance < @.requested)]"
}

When the available balance is insufficient, the workflow continues to envelope-rejecter. The request is rejected automatically with a predefined rejection reason:

{
  "id": "reject",
  "type": "envelope-rejecter",
  "description": "Insufficient balance — reject on behalf of this approver mailbox",
  "config": {
    "rejectionReason": "Insufficient vacation balance"
  },
  "next": []
}

Automation payload

{
  "name": "Vacation request auto-approval",
  "active": true,
  "workflow": [
    {
      "id": "trigger",
      "type": "envelope-trigger",
      "description": "Catch vacation request envelopes awaiting this mailbox's approval",
      "config": {
        "template": [
          "<vacation-request-template-uuid>"
        ],
        "status": [
          "WAITING"
        ]
      },
      "next": [
        "build-request"
      ]
    },
    {
      "id": "build-request",
      "type": "xslt-converter",
      "description": "Build the balance-check request body from envelope fields",
      "config": {
        "filename": "balance-request.json",
        "map": "<xslt stylesheet — see 'Build the balance request' above>"
      },
      "next": [
        "call-balance-api"
      ]
    },
    {
      "id": "call-balance-api",
      "type": "api-caller",
      "description": "Call external HR/leave-management API (must echo back requestedDays)",
      "config": {
        "url": "https://hr.example.com/api/vacation-balance",
        "method": "post",
        "contentType": "application/json",
        "filename": "balance-response.json"
      },
      "next": [
        "if-sufficient",
        "if-insufficient"
      ]
    },
    {
      "id": "if-sufficient",
      "type": "if-condition",
      "description": "balance >= requested",
      "config": {
        "executor": "jsonpath",
        "expression": "$[?(@.balance >= @.requested)]"
      },
      "next": [
        "approve"
      ]
    },
    {
      "id": "if-insufficient",
      "type": "if-condition",
      "description": "balance < requested — exact logical complement of if-sufficient",
      "config": {
        "executor": "jsonpath",
        "expression": "$[?(@.balance < @.requested)]"
      },
      "next": [
        "reject"
      ]
    },
    {
      "id": "approve",
      "type": "envelope-approver",
      "description": "Sufficient balance — approve on behalf of this approver mailbox, sending the envelope forward",
      "config": {},
      "next": []
    },
    {
      "id": "reject",
      "type": "envelope-rejecter",
      "description": "Insufficient balance — reject on behalf of this approver mailbox",
      "config": {
        "rejectionReason": "Insufficient vacation balance"
      },
      "next": []
    }
  ]
}

The automation must run for the mailbox that holds the pending approver role. Both envelope-approver and envelope-rejecter act on that mailbox's pending approval step, just as the approver would when processing the request manually.

The example uses a static Insufficient vacation balance rejection reason. A dynamic reason can be used if the external API already returns an appropriate message that can be passed to the rejection operation.

AI Review of a Membership Application

This example uses AI to review a membership application and automatically write the generated result back into the envelope. The workflow extracts the applicant's answer, builds an AI prompt, sends it to OpenAI, converts the AI response into XML, and fills the aiSummary field in the envelope.

The workflow uses the following automation types:

Template structure

The example template uses two roles and two fields on the same document:

• Role 0 — applicant fills applicationText.

• Role 1 — assignee owns the empty aiSummary field that is populated by the automation.

When the applicant sends the envelope with applicationText completed, the envelope moves to WAITING. The automation catches the envelope when Role 1 becomes active.

Build the AI prompt

Use parameter-extractor with the xpath executor to build a prompt from the value of applicationText.

{
  "executor": "xpath",
  "outputParams": [
    "prompt"
  ],
  "expressions": [
    "concat('Summarize this membership application in one sentence: ', //field[@name=\"applicationText\"])"
  ]
}

The prompt output parameter is passed directly to the next openai operation. Because the parameter name matches the prompt input expected by openai, the prompt property can be omitted from the OpenAI operation configuration.

Configure the AI operation

The openai automation type requires a stored OpenAI credential. Create it first:

POST /api/v1/automation/account/{accountId}/credentials

{
  "name": "openai-membership-review",
  "type": "openai",
  "data": {
    "apiKey": "<real-key>"
  }
}

A successful request returns the credential ID:

{
  "id": "<credential-uuid>"
}

Use this value as credentialsId in the openai workflow item.

The openai operation can then be configured as follows:

{
  "type": "openai",
  "config": {
    "model": "gpt-4o",
    "filename": "ai-response.json"
  },
  "credentialsId": "<stored-openai-credential-id>"
}

The same workflow can use gemini instead of openai. The credential type, credentialsId, and automation type must be changed accordingly.

Convert the AI response

The AI response is JSON, while envelope-filler ultimately requires an XML fill payload. Use json2xml-converter before the XSLT transformation.

For an OpenAI response with the following shape:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "Test AI response text"
      }
    }
  ]
}

json2xml-converter produces XML in which the response text can be selected with:

/root/choices/message/text()

Use this XPath in the following xslt-converter operation when building the envelope fill payload.

Build the envelope fill payload

The xslt-converter must create the XML structure expected by the envelope fill operation. The generated payload includes the target field and places the AI response into aiSummary.

<envelope templateUuid="<template-uuid>" templateVersion="<template-version>">
  <info>
    <subject>Membership application</subject>
    <message></message>
    <forwarding delegation="false" sharing="false"/>
  </info>
  <flow>
    <roles>
      <role id="0" mailboxUuid="<applicant-mailbox-uuid>"/>
      <role id="1" mailboxUuid="<automation-mailbox-uuid>"/>
    </roles>
  </flow>
  <documents>
    <document id="0">
      <field name="aiSummary">
        <xsl:value-of select="/root/choices/message/text()"/>
      </field>
    </document>
  </documents>
</envelope>

The template UUID, template version, and role mailbox UUIDs are static values for the template used by this automation. The AI-generated response is inserted dynamically into the aiSummary field.

Automation payload

{
  "name": "AI review of membership application",
  "active": true,
  "workflow": [
    {
      "id": "trigger",
      "type": "envelope-trigger",
      "description": "Catch membership applications awaiting this mailbox's review",
      "config": {
        "template": [
          "<membership-application-template-uuid>"
        ],
        "status": [
          "WAITING"
        ]
      },
      "next": [
        "build-prompt"
      ]
    },
    {
      "id": "build-prompt",
      "type": "parameter-extractor",
      "description": "Build the AI prompt from the applicant's answer",
      "config": {
        "executor": "xpath",
        "outputParams": [
          "prompt"
        ],
        "expressions": [
          "concat('Summarize this membership application in one sentence: ', //field[@name=\"applicationText\"])"
        ]
      },
      "next": [
        "ask-ai"
      ]
    },
    {
      "id": "ask-ai",
      "type": "openai",
      "description": "Generate a summary from the membership application",
      "config": {
        "model": "gpt-4o",
        "filename": "ai-response.json"
      },
      "credentialsId": "<stored-openai-credential-id>",
      "next": [
        "to-xml"
      ]
    },
    {
      "id": "to-xml",
      "type": "json2xml-converter",
      "description": "Convert the AI response from JSON to XML",
      "config": {},
      "next": [
        "build-fill"
      ]
    },
    {
      "id": "build-fill",
      "type": "xslt-converter",
      "description": "Build the envelope fill payload from the AI response",
      "config": {
        "filename": "fill.xml",
        "map": "<xslt stylesheet using /root/choices/message/text() to populate aiSummary>"
      },
      "next": [
        "fill-field"
      ]
    },
    {
      "id": "fill-field",
      "type": "envelope-filler",
      "description": "Write the AI response into aiSummary and complete the assignee step",
      "config": {},
      "next": []
    }
  ]
}

When the workflow completes successfully, envelope-filler writes the generated text into aiSummary. In the verified scenario, Role 1 is the last active role, so filling the field completes the envelope and moves it from WAITING to COMPLETED.

Related topics

• Create an Automation

• Credentials

• Automation Executions and Logs

• Envelope automation types

• Integration automation types

• Validation and Logic automation types