> ## Documentation Index
> Fetch the complete documentation index at: https://widgetic.com/llms.txt
> Use this file to discover all available pages before exploring further.

# List the compositions a workflow can show, and what each can do

> The workspace's compositions as the workflow editor offers them, newest first. For each one: whether it can be
shown (its widget has a published version), the websites it may be embedded on, and which triggers it supports.

- **Input added** (`inputs`) is enabled only for a composition that declares at least one table a visitor's
  entries can be written to. Its `tables` are all of them; its `fields` are the columns a rule may read (not
  `id` and `created_at`, not a column that is not text, a number or yes/no, and not one whose name says it holds
  a person's private details, such as an email or a phone number).
- **Action in the widget** (`actions`) is enabled only when the published widget version declares at least one
  goal. Its `items` are the goals a trigger can wait for.

When one of them is not enabled, `reason` says why (`widget_keeps_no_data`, `widget_reports_no_actions` or
`widget_not_published`), so the editor can show the trigger disabled with an explanation. Publishing checks every
reference again against what the composition can do at that moment.
For personal workspace, use 'personal' as workspaceId.
For organization workspace, use the organization UUID as workspaceId. Any active member can read it.




## OpenAPI

````yaml /openapi/widgetic-api-public.json get /workspaces/{workspaceId}/workflows/composition-options
openapi: 3.0.0
info:
  title: Widgetic API Gateway
  version: 1.0.0
  description: API documentation for the Widgetic API Gateway
  license:
    name: Widgetic Integration License
    url: https://docs.widgetic.com/resources/license
servers:
  - url: https://api.widgetic.com/v1
    description: Production server
    variables:
      env:
        default: production
        description: Environment
      apiUrl:
        default: https://api.widgetic.com
        description: API URL
      apiVersion:
        default: /v1
        description: API Version path prefix
security: []
tags: []
paths:
  /workspaces/{workspaceId}/workflows/composition-options:
    get:
      tags:
        - Workflows
      summary: List the compositions a workflow can show, and what each can do
      description: >
        The workspace's compositions as the workflow editor offers them, newest
        first. For each one: whether it can be

        shown (its widget has a published version), the websites it may be
        embedded on, and which triggers it supports.


        - **Input added** (`inputs`) is enabled only for a composition that
        declares at least one table a visitor's
          entries can be written to. Its `tables` are all of them; its `fields` are the columns a rule may read (not
          `id` and `created_at`, not a column that is not text, a number or yes/no, and not one whose name says it holds
          a person's private details, such as an email or a phone number).
        - **Action in the widget** (`actions`) is enabled only when the
        published widget version declares at least one
          goal. Its `items` are the goals a trigger can wait for.

        When one of them is not enabled, `reason` says why
        (`widget_keeps_no_data`, `widget_reports_no_actions` or

        `widget_not_published`), so the editor can show the trigger disabled
        with an explanation. Publishing checks every

        reference again against what the composition can do at that moment.

        For personal workspace, use 'personal' as workspaceId.

        For organization workspace, use the organization UUID as workspaceId.
        Any active member can read it.
      operationId: listWorkspaceWorkflowCompositionOptions
      parameters:
        - $ref: '#/components/parameters/WorkflowWorkspaceId'
        - name: search
          in: query
          required: false
          description: Text the composition's name must contain
          schema:
            type: string
            maxLength: 120
        - name: ids
          in: query
          required: false
          description: >
            Only these compositions (comma-separated ids, at most 50), those of
            them you may see. Ask for the

            compositions a workflow shows with this, so each is found whatever
            page it would be on. An id you may not

            see is left out, as one that does not exist is.
          schema:
            type: string
        - name: limit
          in: query
          required: false
          description: Page size (1-100, 50 when not given)
          schema:
            type: integer
        - name: offset
          in: query
          required: false
          description: How many to skip (0 when not given)
          schema:
            type: integer
        - $ref: '#/components/parameters/ManagedUserScopeId'
        - $ref: '#/components/parameters/ManagedUserScopeExternalId'
      responses:
        '200':
          description: The compositions the editor can offer
          content:
            application/json:
              schema:
                type: object
                properties:
                  success:
                    type: boolean
                    example: true
                  data:
                    $ref: '#/components/schemas/WorkflowCompositionOptions'
                  meta:
                    $ref: '#/components/schemas/ResponseMeta'
                required:
                  - success
                  - data
        '400':
          description: >-
            The workspace is neither "personal" nor an organization id, or ids
            is not a list of at most 50 composition ids
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '403':
          description: >-
            Forbidden - Not a member of this organization, the plan does not
            include workflows (`AUTHZ_PLAN_RESTRICTION`), or the call is made
            for one managed user (`X-Managed-User-Id`) in a workspace other than
            `personal` (`MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '503':
          description: Workflows cannot be used on this server right now
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
      security:
        - apiKeyAuth: []
components:
  parameters:
    WorkflowWorkspaceId:
      name: workspaceId
      in: path
      required: true
      description: >
        The workspace: 'personal' for your own workspace, or the UUID of an
        organization. A call made for one of your

        managed users (`X-Managed-User-Id`) always uses 'personal': a managed
        user has no other workspace, and a call

        that names an organization is refused with 403.
      schema:
        type: string
      example: personal
    ManagedUserScopeId:
      in: header
      name: X-Managed-User-Id
      required: false
      description: >-
        The id Widgetic gave the managed user (`POST /managed-users`). Makes
        this call for one of your managed users, so that a mistake in your own
        code cannot reach another customer's work. Send this header, or the
        other one, never both. Left out, the call works on your whole account,
        as it always has. With it, the call reaches only that user's
        compositions and workflows: a list shows only theirs, a composition or a
        workflow the call makes is filed under them, and one of another user, or
        one that does not exist, answers `404` (the same answer, so the call
        cannot be used to find out what another customer has). A managed user
        that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty,
        repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`;
        an empty header is never read as no header. A call that is about the
        whole account, such as the list of your managed users, is refused with
        `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the
        header. Only your API key can send it. The header is a limit the call
        asks for: whoever holds the key can leave it out, so for a credential
        that a customer's browser holds, use an editor session. An
        `Idempotency-Key` is kept apart for each managed user.
      schema:
        type: string
        format: uuid
        example: 3f2b8c1e-7a4d-4e0b-9c55-2d1a6b7e8f90
    ManagedUserScopeExternalId:
      in: header
      name: X-Managed-User-External-Id
      required: false
      description: >-
        Your own id for the managed user (its `externalId`), when you do not
        keep Widgetic's. Makes this call for one of your managed users, so that
        a mistake in your own code cannot reach another customer's work. Send
        this header, or the other one, never both. Left out, the call works on
        your whole account, as it always has. With it, the call reaches only
        that user's compositions and workflows: a list shows only theirs, a
        composition or a workflow the call makes is filed under them, and one of
        another user, or one that does not exist, answers `404` (the same
        answer, so the call cannot be used to find out what another customer
        has). A managed user that is not yours answers `404` with
        `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is
        `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read
        as no header. A call that is about the whole account, such as the list
        of your managed users, is refused with `403` and
        `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header.
        Only your API key can send it. The header is a limit the call asks for:
        whoever holds the key can leave it out, so for a credential that a
        customer's browser holds, use an editor session. An `Idempotency-Key` is
        kept apart for each managed user.
      schema:
        type: string
        minLength: 1
        maxLength: 255
        example: customer-1042
  schemas:
    WorkflowCompositionOptions:
      type: object
      required:
        - items
        - total
        - limit
        - offset
      properties:
        items:
          type: array
          items:
            $ref: '#/components/schemas/WorkflowCompositionOption'
        total:
          type: integer
        limit:
          type: integer
        offset:
          type: integer
      example:
        items:
          - Example WorkflowCompositionOption
        total: 42
        limit: 42
        offset: 42
    ResponseMeta:
      type: object
      description: >-
        Extra information about the answer: where a page sits in a list, the
        cursor of the next page, or warnings about a call that succeeded with a
        caveat.
      additionalProperties: true
      properties:
        page:
          type: integer
          description: The page that was read, counting from 1.
          example: 1
        size:
          type: integer
          description: How many items one page holds.
          example: 20
        total:
          type: integer
          description: How many items the whole list has.
          example: 135
        limit:
          type: integer
          description: The same as `size`.
          example: 20
        offset:
          type: integer
          description: How many items come before this page.
          example: 0
        hasNextPage:
          type: boolean
          example: true
        hasPreviousPage:
          type: boolean
          example: false
        nextCursor:
          type: string
          nullable: true
          description: >-
            Pass this as `cursor` to read the next page of a list that is read
            by cursor. `null` on the last page.
        warnings:
          type: array
          items:
            type: string
          description: >-
            Things the call did not do, though it succeeded (for example a table
            that could not be created just now).
    ErrorResponse:
      type: object
      required:
        - success
        - message
        - error
      additionalProperties: true
      properties:
        success:
          type: boolean
          description: Always `false` on a failure.
          example: false
        message:
          type: string
          description: The same text as `error.message`, for a caller that reads one line.
        error:
          $ref: '#/components/schemas/ErrorDetail'
    WorkflowCompositionOption:
      type: object
      description: >
        One composition a workflow can show, and what it can feed into a
        workflow. `inputs` is enabled only when the

        composition declares at least one table a visitor's entries can be
        written to; `actions` only when its

        published widget version declares at least one goal. When one is not
        enabled, `reason` says why.
      required:
        - id
        - name
        - published
        - allowedWebsites
        - inputs
        - actions
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
        thumbnailUrl:
          type: string
          nullable: true
        published:
          type: boolean
          description: >-
            Whether the composition can be shown at all (its widget has a
            published version).
        allowedWebsites:
          type: array
          description: >-
            The websites the composition may be embedded on; empty means
            anywhere.
          items:
            type: string
        inputs:
          type: object
          required:
            - enabled
            - tables
            - fields
          properties:
            enabled:
              type: boolean
            reason:
              type: string
              nullable: true
              description: >
                Why Input added is not available. widget_keeps_no_data means the
                composition declares no table a

                visitor's entries are written to; widget_not_published means the
                widget has no published version.
              enum:
                - widget_keeps_no_data
                - widget_not_published
            tables:
              type: array
              description: >-
                Every table a visitor's entries are written to, including one
                with no field a rule may read.
              items:
                type: string
            fields:
              type: array
              description: >
                The columns of those tables a rule may read. Not offered are id
                and created_at, columns that are not

                text, a number or yes/no, and columns whose name says they hold
                a person's private details (an email,

                a phone number), because a value a rule reads is handed to the
                visitor's page.
              items:
                $ref: '#/components/schemas/WorkflowCompositionField'
        actions:
          type: object
          required:
            - enabled
            - items
          properties:
            enabled:
              type: boolean
            reason:
              type: string
              nullable: true
              description: >
                Why Action in the widget is not available.
                widget_reports_no_actions means the published widget

                declares no goals; widget_not_published means the widget has no
                published version.
              enum:
                - widget_reports_no_actions
                - widget_not_published
            items:
              type: array
              items:
                $ref: '#/components/schemas/WorkflowCompositionAction'
      example:
        id: 3fa85f64-5717-4562-b3fc-2c963f66afa6
        name: Example name
        thumbnailUrl: Example thumbnailUrl
        published: true
        allowedWebsites: []
        inputs: {}
        actions: {}
    ErrorDetail:
      type: object
      required:
        - code
        - message
        - timestamp
      properties:
        code:
          type: string
          description: Machine-readable error code.
          example: RESOURCE_NOT_FOUND
        message:
          type: string
          description: Human-readable explanation.
          example: Composition not found
        param:
          type: string
          description: The field that caused the error, when one did.
          example: name
        docUrl:
          type: string
          description: Where this error is explained.
        suggestedAction:
          type: string
          description: What to do about it.
        retryAfter:
          type: integer
          description: >-
            Seconds to wait before trying again (rate limits). The same number
            is in the `Retry-After` header.
          example: 60
        details:
          type: object
          additionalProperties: true
          description: >-
            More about the error: the fields that failed, a limit that was
            reached.
        correlationId:
          type: string
          description: Quote this when you ask support about the call.
          example: req_123e4567-e89b-12d3-a456-426614174000
        timestamp:
          type: string
          format: date-time
          example: '2026-10-15T10:00:00.000Z'
    WorkflowCompositionField:
      type: object
      required:
        - table
        - column
        - label
        - type
      properties:
        table:
          type: string
        column:
          type: string
        label:
          type: string
        type:
          type: string
          enum:
            - text
            - number
            - boolean
      example:
        table: Example table
        column: Example column
        label: Example label
        type: Example type
    WorkflowCompositionAction:
      type: object
      required:
        - id
        - metric
        - label
      properties:
        id:
          type: string
          description: >
            What the trigger stores to say which action it waits for. It is the
            goal, and the element when the goal

            names one (clicks, or clicks@.buy-now).
        metric:
          type: string
          description: The goal's metric (clicks, submissions or plays).
        label:
          type: string
        selector:
          type: string
          nullable: true
          description: The element the goal is about, when it names one.
      example:
        id: Example id
        metric: Example metric
        label: Example label
        selector: Example selector
  securitySchemes:
    apiKeyAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.