The mirror column displays values from another board through a linked item. This allows users to surface data from connected boards without duplication, making it easy to see relevant information across multiple boards in one view.

Via the API, the mirror column supports read and create operations. Mirror column values cannot be updated or cleared directly — they reflect the source column's value on the connected board. Filtering mirrored content is not supported.

Column Type	Implementation Type	Supported Operations
`mirror`	`MirrorValue`	Read: Yes Filter: No Create: Yes Update: No Clear: No

Queries

Mirror columns can be queried through the column_values field on items using an inline fragment on MirrorValue.

query {
  items(ids: [1234567890, 9876543210]) {
    name
    column_values {
      ... on MirrorValue {
        id
        display_value
        mirrored_items {
          linked_item {
            id
            name
          }
          mirrored_value {
            ... on StatusValue {
              label
              index
            }
            ... on TextValue {
              text
            }
          }
        }
      }
    }
  }
}

const query = `
  query ($itemIds: [ID!]) {
    items(ids: $itemIds) {
      name
      column_values {
        ... on MirrorValue {
          id
          display_value
          mirrored_items {
            linked_item {
              id
              name
            }
            mirrored_value {
              ... on StatusValue {
                label
              }
              ... on TextValue {
                text
              }
            }
          }
        }
      }
    }
  }
`;

const variables = { itemIds: [1234567890, 9876543210] };

const response = await mondayApiClient.request(query, variables);

📘
Use display_value for a quick text summary of the mirrored content. Use mirrored_items with inline fragments on the mirrored_value field to access the full typed value from the source column.

Fields

You can use the following fields to specify what information your MirrorValue implementation will return.

Field	Description
column `Column!`	The column the value belongs to.
display_value `String!`	The mirrored content as a comma-separated text string.
id `ID!`	The column's unique identifier.
mirrored_items `[MirroredItem!]!`	The linked items and their mirrored values. See `MirroredItem` below.
text `String`	Returns `null`. Use `display_value` instead.
type `ColumnType!`	The column's type.
value `JSON`	Returns `null`. Use `mirrored_items` instead.

MirroredItem

Each MirroredItem represents one linked item and its mirrored value.

Field	Description
linked_board `Board!`	The board that the linked item belongs to.
linked_board_id `ID!`	The linked board's unique identifier.
linked_item `Item!`	The linked item.
mirrored_value `MirroredValue`	The value from the source column, returned as a union of all column value types. Use inline fragments to access type-specific fields.

MirroredValue

MirroredValue is a union type that can resolve to any column value type (e.g., StatusValue, TextValue, NumbersValue). Use inline fragments to access the fields of the specific type:

mirrored_value {
  ... on StatusValue {
    label
    index
  }
  ... on NumbersValue {
    number
  }
  ... on DateValue {
    date
    time
  }
}

Example response

{
  "data": {
    "items": [
      {
        "name": "Task A",
        "column_values": [
          {
            "id": "mirror",
            "display_value": "Done, Working on it",
            "mirrored_items": [
              {
                "linked_item": {
                  "id": "9876543210",
                  "name": "Linked Task 1"
                },
                "mirrored_value": {
                  "label": "Done",
                  "index": 1
                }
              },
              {
                "linked_item": {
                  "id": "9876543211",
                  "name": "Linked Task 2"
                },
                "mirrored_value": {
                  "label": "Working on it",
                  "index": 0
                }
              }
            ]
          }
        ]
      }
    ]
  }
}

Mutations

Create

Required scope: boards:write

You can create a mirror column using the generic create_column mutation with column_type: mirror. The defaults argument defines the mirror's configuration, including which connect boards column to use and which columns from the linked board to display.

mutation {
  create_column(
    board_id: 1234567890
    title: "Linked Status"
    column_type: mirror
    defaults: "{\"settings\": {\"relation_column\": {\"board_relation\": true}, \"displayed_linked_columns\": [{\"board_id\": \"9876543210\", \"column_ids\": [\"status\"]}]}}"
  ) {
    id
    title
    type
    settings
  }
}

Configuration fields

The defaults JSON object accepts the following settings:

Field	Type	Description
`relation_column`	`Object`	Maps a connect boards column ID to `true`. Specifies which board relation column provides the linked items. E.g., `{"board_relation": true}`.
`displayed_linked_columns`	`Array`	Array of objects specifying which columns to mirror from each linked board. Each object has `board_id` (string) and `column_ids` (array of column ID strings).
`sumType`	`String`	Aggregation type for status mirrors. Values: `"doneOnly"` (shows done percentage) or `"allStatuses"` (shows all status counts).
`calcType`	`String`	Calculation type for date mirrors. Values: `"earliestToLatest"`, `"earliest"`, or `"latest"`.

Reading column configuration

To retrieve a mirror column's settings, query its settings field.

🚧
The settings_str field is deprecated as of API version 2025-10. Use the typed settings object instead, which returns structured JSON rather than a JSON-encoded string.

query {
  boards(ids: 1234567890) {
    columns(ids: ["mirror"]) {
      id
      title
      settings
    }
  }
}

`settings` response structure

The settings field returns a typed JSON object with these keys:

Key	Type	Description
`relation_column`	`Object`	Maps the connect boards column ID to `true`.
`displayed_linked_columns`	`Array`	Array of objects with `board_id` and `column_ids` specifying which columns are mirrored.
`sumType`	`String`	The aggregation type for status mirrors (if configured).
`calcType`	`String`	The calculation type for date mirrors (if configured).

Example `settings` response

{
  "relation_column": {
    "board_relation": true
  },
  "displayed_linked_columns": [
    {
      "board_id": "9876543210",
      "column_ids": ["status", "date"]
    }
  ]
}

Get column type schema

You can retrieve the JSON schema for the mirror column's settings programmatically using the get_column_type_schema query. This returns the structure, validation rules, and available properties for the column's configuration.

query {
  get_column_type_schema(
    type: mirror
  )
}

{
  "data": {
    "get_column_type_schema": {
      "schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "type": "object",
        "properties": {
          "settings": {
            "type": "object",
            "description": "Column specific settings",
            "properties": {
              "relation_column": {
                "type": "object",
                "description": "Map of relation-column ID to a boolean flag",
                "additionalProperties": {
                  "type": "boolean"
                }
              },
              "displayed_linked_columns": {
                "type": "array",
                "description": "Array of entries mapping a linked board to the columns to display",
                "items": {
                  "type": "object",
                  "properties": {
                    "board_id": { "type": "string" },
                    "column_ids": {
                      "type": "array",
                      "items": { "type": "string" }
                    }
                  },
                  "required": ["board_id", "column_ids"],
                  "additionalProperties": false
                }
              },
              "sumType": {
                "type": "string",
                "description": "Aggregation type for status summaries",
                "enum": ["doneOnly", "allStatuses"]
              },
              "calcType": {
                "type": "string",
                "description": "Calculation type for linked date aggregation",
                "enum": ["earliestToLatest", "earliest", "latest"]
              }
            },
            "additionalProperties": false
          }
        }
      }
    }
  }
}

The response includes property names, types, constraints (such as max lengths and allowed values), and descriptions for each setting. You can use this to validate column settings, dynamically generate UIs, or give context to AI agents. Learn more about the schema response format.