Create Automation

Use the createAutomation mutation to build an automation in a workspace: a single trigger (the event to watch for) plus one or more actions that run when the trigger fires. Automations are workspace-scoped (workspaces are Workspace objects in the API) and are created in an active state by default.

The automation is created in the workspace identified by the blue-workspace-id header, which accepts a workspace ID or slug.

Request

The smallest automation needs a trigger type and at least one action. This one adds a tag to every record (Record) the moment it is created.

mutation CreateAutomation {
  createAutomation(
    input: { trigger: { type: TODO_CREATED }, actions: [{ type: ADD_TAG, tagIds: ["tag_123"] }] }
  ) {
    id
    isActive
    trigger {
      id
      type
    }
    actions {
      id
      type
    }
    createdAt
  }
}

Parameters

CreateAutomationInput

The automation’s record table

Every automation belongs to one record table. databaseId on createAutomation names it; when omitted, Blue resolves it as the workspace’s only live table, and refuses an ambiguous workspace. The trigger and action fieldId/optionIds inputs below resolve against that table’s mounted fields; a field not mounted on it fails with Automation field <id> is not mounted on its table.

CreateAutomationTriggerInput

The trigger fields that apply depend on type. Most fields are filters that narrow when the trigger fires; schedule is only for SCHEDULED triggers, and conditionMode is only for CONDITIONAL triggers.

CreateAutomationTriggerScheduleInput

Configures a SCHEDULED trigger. hour, minute, and timezone are always required; the other fields are used by specific type values (e.g. dayOfWeek for WEEKLY, dayOfMonth for MONTHLY, cronExpression for CUSTOM).

AutomationTriggerMetadataInput

CreateAutomationActionInput

The fields that apply depend on type — e.g. tagIds for ADD_TAG/REMOVE_TAG, assigneeIds for ADD_ASSIGNEE, duedIn for CHANGE_DUE_DATE, metadata.email for SEND_EMAIL, httpOption for MAKE_HTTP_REQUEST.

AutomationActionMetadataInput

AutomationActionSendEmailInput

Used by SEND_EMAIL actions. to, content, and subject are required; the rest are optional.

AutomationActionSendEmailAttachmentInput

AutomationActionCreateChecklistInput

Used by CREATE_CHECKLIST actions. title and position are required.

AutomationActionCreateChecklistItemInput

AutomationActionHttpOptionInput

Used by MAKE_HTTP_REQUEST actions.

HttpHeaderInput / HttpParameterInput

HttpAuthorizationBasicAuthInput

HttpAuthorizationApiKeyInput

AutomationTriggerType

AutomationActionType

AutomationScheduleType

CopyRecordOption

What to carry over when a COPY_TODO action runs: DESCRIPTION, DUE_DATE, ASSIGNEES, TAGS, COMMENTS, CHECKLISTS, CUSTOM_FIELDS.

Response

createAutomation returns the created Automation. The example above resolves to:

{
  "data": {
    "createAutomation": {
      "id": "clm4n8qwx000008l0g4oxdqn7",
      "isActive": true,
      "trigger": {
        "id": "clm4n8r2k000108l0b7y2f3qd",
        "type": "TODO_CREATED"
      },
      "actions": [
        {
          "id": "clm4n8r7p000208l0c9k4h5wz",
          "type": "ADD_TAG"
        }
      ],
      "createdAt": "2026-05-29T14:21:08.000Z"
    }
  }
}

Returns

Full example

A TODO_LIST_CHANGED trigger scoped to one list, with four actions: set a due date, add assignees, send an email, and call a webhook. Note contentType: JSON, authorizationType: BEARER, and the required email fields (to, subject, content).

mutation CreateAutomationAdvanced {
  createAutomation(
    input: {
      trigger: {
        type: TODO_LIST_CHANGED
        todoListId: "list_123"
        tagIds: ["tag_123"]
        assigneeIds: ["user_123"]
        color: "#FF5733"
      }
      actions: [
        { type: CHANGE_DUE_DATE, duedIn: 7 }
        { type: ADD_ASSIGNEE, assigneeIds: ["user_123", "user_456"] }
        {
          type: SEND_EMAIL
          metadata: {
            email: {
              to: ["team@example.com"]
              subject: "Record moved to In Progress"
              content: "<p>A record has been moved.</p>"
              cc: ["manager@example.com"]
              replyTo: ["ops@example.com"]
            }
          }
        }
        {
          type: MAKE_HTTP_REQUEST
          httpOption: {
            url: "https://api.example.com/webhook"
            method: POST
            contentType: JSON
            body: "{\"event\": \"record_moved\"}"
            headers: [{ key: "X-Custom-Header", value: "automation" }]
            authorizationType: BEARER
            authorizationBearerToken: "YOUR_BEARER_TOKEN"
          }
        }
      ]
    }
  ) {
    id
    isActive
    trigger {
      id
      type
      color
      todoList {
        id
        title
      }
      tags {
        id
        title
      }
      assignees {
        id
        fullName
        email
      }
    }
    actions {
      id
      type
      duedIn
      assignees {
        id
        fullName
      }
      metadata {
        ... on AutomationActionMetadataSendEmail {
          email {
            to
            subject
          }
        }
      }
      httpOption {
        url
        method
        contentType
      }
    }
    createdBy {
      id
      fullName
      email
    }
    createdAt
  }
}

Scheduled automation

A SCHEDULED trigger requires a schedule. This one fires every Monday at 9:00 AM Eastern (dayOfWeek: [1]) and copies the record with its assignees and tags.

mutation CreateScheduledAutomation {
  createAutomation(
    input: {
      trigger: {
        type: SCHEDULED
        schedule: { type: WEEKLY, hour: 9, minute: 0, timezone: "America/New_York", dayOfWeek: [1] }
      }
      actions: [{ type: COPY_TODO, metadata: { copyTodoOptions: [ASSIGNEES, TAGS, CHECKLISTS] } }]
    }
  ) {
    id
    trigger {
      id
      type
      schedule {
        type
        hour
        minute
        timezone
        dayOfWeek
        nextExecutionAt
      }
    }
  }
}

Conditional automation

A CONDITIONAL trigger fires when a record starts (or stops) matching a saved filter. Set conditionMode to STARTS_MATCHING or STOPS_MATCHING. The filter itself lives in the opaque filterGroups/filterGroupLinks payload — build it in the workspace automation UI and read it back; it is not meant to be hand-authored.

mutation CreateConditionalAutomation {
  createAutomation(
    input: {
      trigger: { type: CONDITIONAL, conditionMode: STARTS_MATCHING, op: AND }
      actions: [{ type: ADD_TAG, tagIds: ["tag_123"] }]
    }
  ) {
    id
    trigger {
      id
      type
      conditionMode
      op
    }
  }
}

Due-date automation

A DUE_DATE_EXPIRED trigger fires when a record’s due date passes. metadata.offset shifts that moment in minutes (negative = before, positive = after); the resolver uses it to schedule the due-date monitoring jobs. This one emails the assignees 60 minutes before the due date, only for incomplete records.

mutation CreateDueDateAutomation {
  createAutomation(
    input: {
      trigger: { type: DUE_DATE_EXPIRED, metadata: { offset: -60, incompleteOnly: true } }
      actions: [
        {
          type: SEND_EMAIL
          metadata: {
            email: {
              to: ["owner@example.com"]
              subject: "A record is due in 1 hour"
              content: "<p>Heads up — this record is due soon.</p>"
            }
          }
        }
      ]
    }
  ) {
    id
    trigger {
      id
      type
      metadata {
        ... on AutomationTriggerMetadataTodoOverdue {
          offset
          incompleteOnly
        }
      }
    }
  }
}

Errors

{
  "errors": [
    {
      "message": "You are not authorized.",
      "extensions": { "code": "FORBIDDEN" }
    }
  ]
}

Permissions

Only OWNER and ADMIN members of an active workspace can create automations. MEMBER and CLIENT cannot, and any role is blocked on an archived workspace.

Related

• Edit an automation
• Copy an automation
• Delete an automation
• Automations overview