Automations

Automations are the core server-side processes that power your AI Builder applications. They define what to do and when to do it, allowing you to create sophisticated workflows, integrate with external systems, and build intelligent applications.

Understanding Automations

In simple words, automations describe what to do and when:

What to do: A sequence of instructions that process data and perform actions
When to do it: Triggers that activate the automation when specific conditions are met

Example:

A HubspotDealsOnSlack automation might send a notification message on Slack every time a new Hubspot deal is created:

The what would be a fetch instruction calling Slack API to send a message
The when would be a URL (webhook) trigger that Hubspot calls whenever a new deal is opened

Triggers

Automations can be activated through different types of triggers, configured at the top of the automation graph:

URL (Webhook/API Endpoint)

When an automation activates its URL trigger, it becomes publicly available through a URL which you can copy from your Workspace graph or source code. You can then use this URL in external services that support webhooks.

From inside the automation, 4 variables give access to input HTTP requests:

body: Request body
headers: Request headers
method: HTTP method (GET, POST, etc.)
query: URL query parameters

By default, these HTTP requests will receive the automation output as a response body. However, an $http variable available inside the automation gives full control over the response:

- set:
    name: $http
    value:
      headers:
        content-type: application/json
      status: 200

You can also use this variable to implement Server-Sent Events (SSE) for streaming responses:

- set:
    name: $http
    value:
      chunk: # Data object that will be sent as an SSE event
        partial: "First part of response"
- set:
    name: $http
    value:
      chunk: # Another chunk
        partial: "Second part of response"

$http is only available in the URL-triggered automation (not in children calls)
Headers cannot be set after the first chunk is sent
When using SSE events, the automation output will also be sent as the last event
SSE automatically sets appropriate headers (Content-Type, Cache-Control, Connection)

For long-running SSE endpoints, you can configure a keep-alive to avoid timeouts:

- set:
    name: $http
    value:
      sseKeepAlive: 5000 # Keep-alive interval in milliseconds (minimum 5000ms)

After this instruction, a data: {"keepAlive": true} chunk will be regularly emitted until the connection ends.

Events

An automation can listen to a list of events. Whenever such events are received, the automation is executed and can access:

payload: Event payload data
source: Event source information (source IP, correlationId, userId, automation, etc.)

These events can be:

Native events: Generated automatically by the platform
Custom events: Emitted from automations in the same workspace
App events: Emitted from installed Apps

Example configuration:

when:
  events:
    - user-login
    - document-uploaded

Workspaces can only listen to a specific subset of native events. See the Supported Native Events section for details.

Schedules

An automation can be regularly triggered based on cron expressions:

when:
  schedules:
    - '0 9 * * 1-5' # Run at 9:00 AM on weekdays

Automations can be scheduled at most every 15 minutes
Schedules use UTC timezone
When scheduled, the automation runs “on the hour” (e.g., a 20-minute schedule starting at 3:14 will run at 3:20, 3:40, etc.)
When successfully scheduled, a runtime.automations.scheduled event is emitted

A helpful tool for creating cron expressions is crontab.guru.

Memory Architecture

Automations can use and modify data across different memory scopes:

Run Scope

User Scope

Session Scope

Global Scope

Socket Scope

Config Scope

$workspace Scope

Except for $workspace, all these contexts can be written to using the set instruction. Written data will be persisted and available in subsequent requests. However, when setting variables inside session/user contexts from an unauthenticated webhook, they will not be persisted.

Working with Variables

Inside your automation instructions, dynamic data can be injected by surrounding a variable name with double braces: {{some.variable.name}}.

Variables can be created and modified using the set instruction and removed using the delete instruction.

For objects or arrays, you can access specific properties:

# Basic property access
{{user.profile.name}}

# Dynamic property access using another variable
{{session.myObjectVariable[{{item.field}}]}}

If session.myObjectVariable equals {"mickey": "house"} and item.field equals mickey, the entire expression resolves to house.

Instructions

Once triggered, automations execute a sequence of instructions in order. Here are the available instructions:

Logic Instructions

Condition

Conditionally execute instructions based on variable values or expressions.

- conditions:
    '{{user.age}} >= 18':
      - set:
          name: status
          value: adult
    '{{user.age}} < 18':
      - set:
          name: status
          value: minor
    default:
      - set:
          name: status
          value: unknown

More details on condition syntax

Repeat

Loop through items or execute instructions multiple times.

# Iterate through an array
- repeat:
    on: '{{users}}'
    do:
      - set:
          name: processedUsers[]
          value: '{{item.name}}'

# Execute a fixed number of times
- repeat:
    until: 5
    do:
      - set:
          name: counter
          value: '{% {{$index}} + 1 %}'

You can also process batches in parallel:

- repeat:
    on: '{{workQueue}}'
    batch:
      size: 3  # Process 3 items by 3 items  in parallel
      interval: 500  # Pause 500ms between batches
    do:
      - process:
          item: '{{item}}'

Break

Stop execution of the current automation or loop.

- break:
    scope: repeat  # Breaks out of the nearest repeat loop

- break:
    scope: automation  # Stops the current automation

- break:
    scope: all  # Stops all parent automations too
    payload:
      reason: "Operation cancelled"

When break is meant to be handled from a parent automation’s try/catch, scope must be set to all.

All

Try/Catch

Handle errors gracefully.

- try:
    do:
      - riskyOperation: {}
    catch:
      - set:
          name: errorInfo
          value: "{{$error}}"
      - emit:
          event: operation-failed
          payload:
            error: "{{$error}}"

The $error variable is accessible both inside and outside the catch block.

Data Instructions

Set Instruction

Create or update variables in different scopes.

# Simple variable assignment
- set:
    name: greeting
    value: "Hello, world!"

# Create or update object property
- set:
    name: user.profile.firstName
    value: "Jane"

# Simple variable assignment
- set:
    name: greeting
    value: "Hello, world!"

# Create or update object property
- set:
    name: user.profile.firstName
    value: "Jane"

# Merge objects
- set:
    name: settings
    type: merge
    value:
      theme: "dark"

# Add item to array
- set:
    name: users[]
    value: 
      id: 123
      name: "Jane Doe"

# Add multiple items to array
- set:
    name: users
    type: merge
    value:
      - id: 124
        name: "Alice"
      - id: 125
        name: "Bob"

Like everywhere else, you can also use expressions in the value parameter:

- set:
    name: counter
    value: '{% {{counter}} + 1 %}'

Delete Instruction

Integration Instructions

Fetch Instruction

Make HTTP requests to external APIs.

  # Basic GET request
  - fetch:
      url: https://api.example.com/users
      method: GET
      headers:
        Authorization: Bearer {{secret.apiToken}}
      output: apiResponse
  
  # POST request with JSON body
  - fetch:
      url: https://api.example.com/users
      method: POST
      body:
        name: "New User"
        email: "user@example.com"
      output: createResponse

  # Basic GET request
  - fetch:
      url: https://api.example.com/users
      method: GET
      headers:
        Authorization: Bearer {{secret.apiToken}}
      output: apiResponse
  
  # POST request with JSON body
  - fetch:
      url: https://api.example.com/users
      method: POST
      body:
        name: "New User"
        email: "user@example.com"
      output: createResponse

Retrieve response headers and status with outputMode: detailed_response :

    # Detailed response with headers
    - fetch:
        url: https://api.example.com/status
        outputMode: detailed_response
        output: fullResponse
    # Access `{{fullResponse.body}}`, `{{fullResponse.headers}}` and `{{fullResponse.status}}`

Other outputMode :

base64 : return the base64 encoded response body
data_url : return the response body encoded as a data_url

  - fetch:
      url: https://api.example.com/upload
      method: POST
      multipart:
        - fieldname: file
          value: "{{fileContent}}" # Can be an ascii string, a base64 encoded string or a buffer array
          filename: report.pdf # Required if value is a file
          contentType: application/pdf
        - fieldname: metadata
          value: "{{fileMetadata}}"
      output: uploadResult

  - fetch:
      url: '...'
      headers:
        Content-Type: application/x-www-form-urlencoded
      body:
        foo: bar

By default, HTTP responses indicating a content-type: text/event-stream header will force their responseMode to detailed_response, and their {{output.body}} will be a stream that can be read in real time from the calling automation :

- fetch:
    url: "some SSE url (i.e openai /chat-completion endpoint)"
    output: output
- repeat:
    'on': '{{output.body}}'
    do:
      - set:
          name: test[]
          value: '{{item}}'

Here, the repeat instruction will block until all chunks have been processed & the HTTP socket is closed.
Each {{item}} will look like this :

{
  "chunk": {
    "data": [
      "data1",
      "data2"
    ]
  }
}

Here, data1 and data2 correspond to 2 individual chunks written by the remote server, which can be grouped together if they were received at the same time.
If these data strings are valid JSON, they will be automatically parsed into objects.

Alternatively, we can emit received chunks so they can be processed asynchronously & concurrently from other automations :

- fetch:
    url: ..
    stream:
      event: chunk
      payload:
        foo: bar

Each chunk will be emitted like this :

{
  "type": "chunk",
  "payload": {
    "chunk": {
      "data": [
        "data1",
        "data2"
      ]
    },
    "additionalPayload": {
      "foo": "bar"
    }
  }
}

An ending chunk can be specified with endChunk :

- fetch:
    url: ..
    stream:
      event: chunk
      endChunk:
        foo: bar

stream option also accepts target and options fields from emit instruction.

The auth.awsv4 parameter allows configuring an access / secret access key pair to automatically sign your request with AWS Signature V4 :

  - fetch:
      url: https://bedrock-runtime.eu-west-3.amazonaws.com/model/{{model}}/invoke
      auth:
        awsv4:
          accessKeyId: ''
          secretAccessKey: ''
          service: bedrock
          region: 'eu-west-3'
      method: POST
      body:
        inputText: Hello
      output: output
      emitErrors: true

service and region are optional and automatically calculated from given url.

Emit Instruction

Trigger events for UI updates or other automations.

- emit:
    event: user-registered
    payload:
      userId: "{{user.id}}"
      timestamp: "{{run.date}}"

- emit:
    event: user-registered
    payload:
      userId: "{{user.id}}"
      timestamp: "{{run.date}}"

- emit:
    event: user-registered
    payload:
      userId: "{{user.id}}"
      timestamp: "{{run.date}}"        
    target:
      userTopic: 'target user topic'        
      sessionId: 'target session id'
      userId: 'target user id'

Disable events persistence :

- emit:
    event: user-registered
    payload:
      userId: "{{user.id}}"
      timestamp: "{{run.date}}"        
    options:
      persist: false

Wait Instruction

Pause execution until a specific event is received.

- emit:
    event: start-processing
    payload:
      documentId: "{{documentId}}"

- wait:
    oneOf:
      - event: processing-complete
        filters:
          payload.documentId: "{{documentId}}"
    timeout: 30  # Defaults to 20 seconds
    output: processingResult

Rate Limit Instruction

Control resource usage with rate limiting.

- rateLimit:
    name: ExternalAPICall
    window: 60  # In seconds (1 minute)
    limit: 5    # Maximum 5 calls per minute
    consumer: "{{user.id}}"  # Per-user limit
    output: limits
- conditions:
    "{{limits.ok}}":
      - fetch:
          url: https://api.example.com/data
    default:
      - emit:
          event: rate-limit-exceeded
          payload:
            retryAfter: "{{limits.retryAfter}}"
            limit: "{{limits.limit}}"
            window: "{{limits.window}}"
            remaining: "{{limits.remaining}}"
            consumer: "{{limits.consumer}}"

Other Instructions

Auth Instruction

Generate authentication tokens for internal API calls. This token cannot be used outside of automations, and is specifically intented for fetch consumption (as an Authorization header).

- auth:
    workspace: true
    output: jwt
- fetch:
    url: https://api.studio.prisme.ai/v2/workspaces/123/webhooks/someAutomation
    headers:
      Authorization: Bearer {{jwt.jwt}}
    output: apiResponse

When fetching a Prismeai automation endpoint with such workspace token, a {{run.authenticatedWorkspaceId}} variable (which cannot be manually set) will be made available to securely check calling workspace.
You can also forward source workspace authentication to a subsequent fetch :

- fetch:
    url: https://api.studio.prisme.ai/v2/workspaces/123/webhooks/someAutomation
    auth:
      prismeai:
        forwardWorkspaceAuth: true
    output: apiResponse

User Topic Instructions

Manage user subscription topics.

User topics allow sending events to multiple users without knowing who they are in advance, automatically granting them read access to these events without requiring any API Key.

# Create a user topic
- createUserTopic:
    topic: project-updates
    userIds: 
      - "{{user1Id}}"
      - "{{user2Id}}"

# Add users to a topic
- joinUserTopic:
    topic: project-updates
    userIds: # Defaults to current user.id
      - "{{newUserId}}"

User topics allow sending events to multiple users without knowing who they are in advance.

Condition and Expression syntax

Conditions allow you to execute different instructions based on contextual information. You can use a powerful expression syntax in conditions and anywhere with {% ... %} delimiters.

Basic Operators

# Comparison operators
{{someAge}} > 18
{{someAge}} >= 18
{{someAge}} < 18
{{someAge}} <= 18
{{someAge}} == 18
{{someAge}} = 18
{{cityName}} = "Toulouse"

# Inequality
{{someAge}} !== 18
{{someAge}} != 18

# String matching
"hello" matches "hel"
"hello" matches {{someArray}}

# Variable checking
{{testedVariable}}      # Is this variable defined?
!{{testedVariable}}     # Is this variable empty?

# Membership testing
{{someValue}} in {{someList}}
{{someKey}} in {{someObject}}
{{someKey}} not in {{someObject}}
{{someKey}} not in "my,string,list"

# Type checking
isArray({{someVariable}})
isObject({{someVariable}})
isString({{someVariable}})
isNumber({{someVariable}})

Logical Operators

# AND operators
{{someAge}} >= 18 and {{cityName}} == "Toulouse"
{{someAge}} >= 18 && {{cityName}} == "Toulouse"

# OR operators
{{someAge}} >= 18 or {{cityName}} == "Toulouse"
{{someAge}} >= 18 || {{cityName}} == "Toulouse"

# Grouping with parentheses
{{someCity}} == "Paris" || ({{someAge}} >= 18 && {{cityName}} == "Toulouse")

# Negation
{{someCity}} == "Paris" || ! ({{someAge}} >= 18 && {{cityName}} == "Toulouse")
{{someCity}} == "Paris" || not ({{someAge}} >= 18 && {{cityName}} == "Toulouse")

Regular Expressions

"luke.skywalker@gmail.com" matches regex("luke|skywalker")
"luke.skywalker@gmail.com" matches regex(/luke|skywalker/)

MongoDB-like Conditional Matches

jsonmatch({{object}}, {{condition}})

Example condition:

{
  "$or": [
    {
      "test": "unknown"
    },
    {
      "one": {
        "$eq": "three"
      }
    }
  ]
}

Date Functions

Parsing and Access

date("2022-04-13T08:00:05.493Z").hour == 8
date({{mydate}}).minute > 34 && date({{mydate}}).minute < 37
date({{mydate}}).second >= 5
date({{mydate}}).date == 23
date({{mydate}}).month >= 6 && date({{mydate}}).month < 10
date({{mydate}}).year == 2022
date({{mydate}}).day == 3
date({{mydate}}).day in {{allowedDays}}
date({{mydate}}).ts == 1649836805493
date({{mydate}}).iso == '2022-04-13T08:00:05.493Z'

Note: Tested values are UTC based, and day starts on 0 for Sunday (so 3 is Wednesday).

Formatting

date("2023-03-31T17:07:23.975Z", "l") == "3/31/2023"
date("2023-03-31T17:07:23.975Z", "DD/MM/YYYY") == "3/31/2023"
date("2023-03-31T17:07:23.975Z", "LT") == "7:07 PM"
date("2023-03-31T17:07:23.975Z", "LT", "fr") == "19:07"
date("2023-03-31T17:07:23.975Z", "lll", "fr") == "31 mars 2023 19:07"
date("2023-03-31T17:07:23.975Z", "l LT") == "3/31/2023 7:07 PM"
date("2023-03-31T17:07:23.975Z", "LT", "fr", "America/New_York") == "13:07"

See all formatting options on Day.js documentation.

Math Functions

Operators

1+1
1+{{someVariable}}
{{firstVar}} * {{secondVar}}
({{firstVar}} * {{secondVar}} + 10) / 2

Functions

rand(50, 150)  # Random number between 50 and 150
rand()  # Random float between 0 and 1

round(10.2)  # 10
round(10.2, 1)  # 10.2
round(10.26, 1)  # 10.3

ceil(10.1)  # 11
ceil(10.9)  # 11

String Functions

# JSON parsing/stringifying
json('{"foo": "bar"}')  # Object { foo: "bar" }
json({"foo": "bar"})  # String '{"foo":"bar"}'

# Unsafe JSON parsing: never raises exception, try to extract a JSON object or array when surrounded by other text
unsafejson('Voici un tableaux: ["un"] !') # ["un"]
unsafejson('Voici un objet :\n ```{"un": 1}```\n !') # {"un": 1}

# String manipulation
split('one,two,three', ',')  # Array ["one", "two", "three"]
join(['one', 'two', 'three'], ',')  # String "one,two,three"
replace('hello world', 'world', 'there')  # String "hello there"

# Sanitize html
sanitize('<b>Bonjour <u>toi</u></b> !') # &#60;b&#62;Bonjour &#60;u&#62;toi&#60;/u&#62;&#60;/b&#62; !

# Remove complex unicode characters (non BMP, non UTF16 surrogates)
sanitize('Bonjour 🌍 ! Ça va ? 我爱你 ❤️') # Bonjour  ! Ça va ? 我爱你 ❤️

URL parsing

Parse URL search params :

URLSearchParams("key1=value1&key2=value2").asJSON  # Object
URLSearchParams({foo: "bar", abc: "xyz"}).asString  # String "foo=bar&abc=xyz"

Or parse a complete URL as an object :

URL("https://user:password@www.google.fr/some/path/?query=string&foo=bar#anchor")

This returns :

{
  href: 'https://user:password@www.google.fr/some/path/?query=string&foo=bar#anchor',
  origin: 'https://www.google.fr',
  protocol: 'https:',
  username: 'user',
  password: 'password',
  host: 'www.google.fr',
  hostname: 'www.google.fr',
  port: '',
  pathname: '/some/path/',
  search: '?query=string&foo=bar',
  searchParams: { "query": "string", "foo": "bar" },
  hash: '#anchor'
}

Or directly access a specific field :

URL("https://user:password@www.google.fr/some/path/?query=string&foo=bar#anchor").hostname # www.google.fr

Arguments

When calling a native instruction or another automation, different arguments can be transmitted. These graphical inputs are not reserved to native instructions, but can also be configured for your own custom automations by specifying expected arguments and their types.

testArguments:  
  do: []  
  name: testArguments
  arguments:
    someString:
      type: string
    someNumber:
      type: number
    someObject:
      type: object
      properties:
        someStringField:
          type: string
    someOtherObject:
      type: object
      properties:
        nestedObject:
          type: object
          properties:
            someField:
              type: number
    someStringArray:
      type: array
      items:
        type: string
    someObjectArray:
      type: array
      items:
        type: object
        properties:
          fieldA:
            type: string
    someRawJSON:
      type: object
      additionalProperties: true          
    someToken:
      type: string        
      secret: true

The someToken argument defined with secret: true is automatically redacted from native runtime events to avoid accidental leaks of sensitive information.

Arguments Validation

Automation arguments can be validated during execution by enabling validateArguments: true:

slug: test
name: test
do: []
when:
  endpoint: true
output: '{{body}}'
arguments:
  body:
    type: object
    required:
      - str
    properties:
      str:
        type: string
      uri:
        type: string
        format: uri
      obj:
        type: object
        required:
          - un
        properties:
          un:
            type: string
            pattern: '^[a-z]+$'
validateArguments: true

Arguments support various validation formats including date, url, time, password, etc. Validation errors immediately stop current and parent automations.

Advanced Automation Patterns

Implement secure webhook endpoints for third-party integrations:

# Webhook automation
slug: hubspot-webhook
name: Hubspot Deal Created
when:
  endpoint: true
do:
  # Validate webhook signature
  - conditions:
      '!{{headers["x-hubspot-signature"]}}':
        - set:
            name: $http
            value:
              status: 401
        - break:
            scope: automation
  
  # Process webhook data
  - set:
      name: newDeal
      value: "{{body.deal}}"
  
  # Notify team on Slack
  - fetch:
      url: "{{config.slackWebhookUrl}}"
      method: POST
      body:
        text: "New deal created: {{newDeal.name}} ({{newDeal.amount}})"
      output: slackResponse
  
  # Return success response
  - set:
      name: output
      value:
        success: true
        message: "Webhook processed successfully"

Implement secure webhook endpoints for third-party integrations:

# Webhook automation
slug: hubspot-webhook
name: Hubspot Deal Created
when:
  endpoint: true
do:
  # Validate webhook signature
  - conditions:
      '!{{headers["x-hubspot-signature"]}}':
        - set:
            name: $http
            value:
              status: 401
        - break:
            scope: automation
  
  # Process webhook data
  - set:
      name: newDeal
      value: "{{body.deal}}"
  
  # Notify team on Slack
  - fetch:
      url: "{{config.slackWebhookUrl}}"
      method: POST
      body:
        text: "New deal created: {{newDeal.name}} ({{newDeal.amount}})"
      output: slackResponse
  
  # Return success response
  - set:
      name: output
      value:
        success: true
        message: "Webhook processed successfully"

Create multi-stage data processing workflows:

# Document processing automation
slug: process-document
name: Process Document
when:
  events:
    - document-uploaded
do:
  # Parse document
  - set:
      name: documentUrl
      value: "{{payload.documentUrl}}"
  
  # Extract text with OCR
  - fetch:
      url: "{{config.ocrServiceUrl}}"
      method: POST
      body:
        url: "{{documentUrl}}"
      output: ocrResult
  
  # Classify document
  - fetch:
      url: "{{config.aiClassifierUrl}}"
      method: POST
      body:
        text: "{{ocrResult.text}}"
      output: classification
  
  # Store results
  - emit:
      event: document-processed
      payload:
        documentId: "{{payload.documentId}}"
        text: "{{ocrResult.text}}"
        category: "{{classification.category}}"
        confidence: "{{classification.confidence}}"

Coordinate multiple AI models for complex tasks:

# AI Orchestration
slug: analyze-product-feedback
name: Analyze Product Feedback
when:
  events:
    - analyze-feedback-request
do:
  # Categorize feedback
  - fetch:
      url: "{{config.llmApiUrl}}/chat-completions"
      method: POST
      body:
        model: "gpt-3.5-turbo"
        messages:
          - role: system
            content: "Categorize this product feedback into one of these categories: Bug, Feature Request, UX Issue, Praise, Other."
          - role: user
            content: "{{payload.feedbackText}}"
      output: categorization
  
  # Extract sentiment and key points
  - fetch:
      url: "{{config.llmApiUrl}}/chat-completions"
      method: POST
      body:
        model: "mistral"
        messages:
          - role: system
            content: "Analyze this product feedback and extract: 1) Sentiment (positive/negative/neutral), 2) Key points as bullet points, 3) Actionability score (1-10)"
          - role: user
            content: "{{payload.feedbackText}}"
      output: analysis
  
  # Store and notify
  - emit:
      event: feedback-analysis-complete
      payload:
        feedbackId: "{{payload.feedbackId}}"
        category: "{{categorization.choices[0].message.content}}"
        analysis: "{{analysis.choices[0].message.content}}"

Supported Native Events

Workspaces can listen to a specific subset of native events:

Workspace Events

App Events

Automation Events

Runtime Events

Best Practices

Modular Design

Error Handling

State Management

Security Best Practices

Performance Optimization

Testing

Next Steps

Blocks

Pages

Deployment

Overview

AI SecureChat

AI Store

AI Knowledge

AI Builder

AI Governance

AI Collection (beta)

AI Insights (beta)

Understanding Automations

Triggers

Memory Architecture

Working with Variables

Instructions

Logic Instructions

Data Instructions

Integration Instructions

Other Instructions

Condition and Expression syntax

Basic Operators

Logical Operators

Regular Expressions

MongoDB-like Conditional Matches

Date Functions

Parsing and Access

Formatting

Math Functions

Operators

Functions

String Functions

URL parsing

Arguments

Arguments Validation

Advanced Automation Patterns

Supported Native Events

Best Practices

Next Steps

Overview

AI SecureChat

AI Store

AI Knowledge

AI Builder

AI Governance

AI Collection (beta)

AI Insights (beta)

​Understanding Automations

​Triggers

​Memory Architecture

​Working with Variables

​Instructions

​Logic Instructions

​Data Instructions

​Integration Instructions

​Other Instructions

​Condition and Expression syntax

​Basic Operators

​Logical Operators

​Regular Expressions

​MongoDB-like Conditional Matches

​Date Functions

​Parsing and Access

​Formatting

​Math Functions

​Operators

​Functions

​String Functions

​URL parsing

​Arguments

​Arguments Validation

​Advanced Automation Patterns

​Supported Native Events

​Best Practices

​Next Steps

Understanding Automations

Triggers

Memory Architecture

Working with Variables

Instructions

Logic Instructions

Data Instructions

Integration Instructions

Other Instructions

Condition and Expression syntax

Basic Operators

Logical Operators

Regular Expressions

MongoDB-like Conditional Matches

Date Functions

Parsing and Access

Formatting

Math Functions

Operators

Functions

String Functions

URL parsing

Arguments

Arguments Validation

Advanced Automation Patterns

Supported Native Events

Best Practices

Next Steps