The dependency column allows you to set up item-to-item dependencies within the same board. These dependencies can be visualized in Gantt views, used in automations, and combined with timeline and date logic.

Via the API, the dependency column supports read, filter, update, and clear operations.

Column Type	Implementation Type	Supported Operations
`dependency`	`DependencyValue`	Read: Yes Filter: Yes Update: Yes Clear: Yes

Queries

Dependency columns can be queried through the column_values field on items queries using an inline fragment on DependencyValue.

query {
  items(ids: [1234567890, 9876543210]) {
    name
    column_values(types: dependency) {
      ... on DependencyValue {
        id
        display_value
        linked_item_ids
        linked_items {
          id
          name
        }
        updated_at
      }
    }
  }
}

const query = `
  query ($itemIds: [ID!], $columnType: [ColumnType!]) {
    items(ids: $itemIds) {
      name
      column_values(types: $columnType) {
        ... on DependencyValue {
          id
          display_value
          linked_item_ids
          linked_items {
            id
            name
          }
          updated_at
        }
      }
    }
  }
`;

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

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

Fields

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

Field	Description
column `Column!`	The column the value belongs to.
display_value `String!`	The names of dependent items, separated by commas. Returns an empty string if no dependencies are set.
id `ID!`	The dependency column's unique identifier.
is_leaf `Boolean!`	Whether the item has no subitems.
linked_item_ids `[ID!]!`	The unique identifiers of the items this item depends on. Returns an empty array if no dependencies are set.
linked_items `[Item!]!`	The dependent items. Returns an empty array if no dependencies are set.
text `String`	Always returns `null`. Use `display_value` instead.
type `ColumnType!`	The column's type (`dependency`).
updated_at `Date`	The column's last updated date. Returns `null` if the value has never been set.
value `JSON`	Always returns `null`. Use `linked_items` and `linked_item_ids` instead.

Example response

{
  "data": {
    "items": [
      {
        "name": "Launch website",
        "column_values": [
          {
            "id": "dependent_on",
            "display_value": "Design review, Content approval",
            "linked_item_ids": ["1234567891", "1234567892"],
            "linked_items": [
              { "id": "1234567891", "name": "Design review" },
              { "id": "1234567892", "name": "Content approval" }
            ],
            "updated_at": "2026-03-20T12:00:00+00:00"
          }
        ]
      }
    ]
  }
}

📘
The text and value fields always return null for dependency columns. Use linked_item_ids or linked_items to access the dependency data, and display_value for a human-readable summary.

🚧
The dependency relationship type (Finish-to-start, Start-to-start, Finish-to-finish, Start-to-finish) is configurable per dependency in the monday.com UI but is not currently exposed by the API. DependencyValue only returns which items are linked — not the relationship type between them.

Filter

You can filter items by dependency values using the items_page object. The dependency column supports the following operators:

Operator	Compare Value	Description
`any_of`	An array of item IDs (e.g., `[1234567890]`)	Returns items that depend on any of the specified items.
`not_any_of`	An array of item IDs (e.g., `[1234567890]`)	Returns items that do not depend on any of the specified items.
`is_empty`	`[]`	Returns items with no dependencies set.
`is_not_empty`	`[]`	Returns items that have at least one dependency set.

Examples

Filter by dependent item ID

This example returns all items that depend on item 9876543210.

query {
  boards(ids: 1234567890) {
    items_page(
      query_params: {
        rules: [
          {
            column_id: "dependent_on"
            compare_value: [9876543210]
            operator: any_of
          }
        ]
      }
    ) {
      items {
        id
        name
      }
    }
  }
}

const query = `
  query ($boardId: [ID!], $columnId: ID!, $operator: ItemsQueryRuleOperator!, $compareValue: CompareValue!) {
    boards(ids: $boardId) {
      items_page(
        query_params: {
          rules: [
            { column_id: $columnId, compare_value: $compareValue, operator: $operator }
          ]
        }
      ) {
        items { id name }
      }
    }
  }
`;

const variables = {
  boardId: 1234567890,
  columnId: "dependent_on",
  compareValue: [9876543210],
  operator: "any_of",
};

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

Exclude items by dependency

This example returns all items that do not depend on item 9876543210.

query {
  boards(ids: 1234567890) {
    items_page(
      query_params: {
        rules: [
          {
            column_id: "dependent_on"
            compare_value: [9876543210]
            operator: not_any_of
          }
        ]
      }
    ) {
      items {
        id
        name
      }
    }
  }
}

Filter for items with dependencies

query {
  boards(ids: 1234567890) {
    items_page(
      query_params: {
        rules: [
          {
            column_id: "dependent_on"
            compare_value: []
            operator: is_not_empty
          }
        ]
      }
    ) {
      items {
        id
        name
      }
    }
  }
}

Mutations

Update

You can update a dependency column using change_multiple_column_values by passing a JSON object in column_values.

Inside the object, provide an item_ids array containing the IDs of the items this item depends on (as strings).

🚧
The change_simple_column_value mutation is not supported for dependency columns. You must use change_multiple_column_values.

mutation {
  change_multiple_column_values(
    item_id: 9876543210
    board_id: 1234567890
    column_values: "{\"dependent_on\": {\"item_ids\": [\"1234567891\", \"1234567892\"]}}"
  ) {
    id
  }
}

const query = `
  mutation ($boardId: ID!, $itemId: ID!, $columnValues: JSON!) {
    change_multiple_column_values(
      item_id: $itemId
      board_id: $boardId
      column_values: $columnValues
    ) {
      id
    }
  }
`;

const variables = {
  boardId: 1234567890,
  itemId: 9876543210,
  columnValues: JSON.stringify({
    dependent_on: {
      item_ids: ["1234567891", "1234567892"]
    }
  }),
};

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

📘
Updating a dependency column replaces the entire list of dependencies. To add a new dependency without removing existing ones, first query the current linked_item_ids, append the new ID, then send the full list.

Set on item creation

You can set dependency values when creating an item by passing the dependency column value in the column_values argument.

mutation {
  create_item(
    board_id: 1234567890
    item_name: "New task"
    column_values: "{\"dependent_on\": {\"item_ids\": [\"9876543210\"]}}"
  ) {
    id
    name
  }
}

Clear

You can clear a dependency column using change_multiple_column_values by passing null or an empty object {} in column_values.

mutation {
  change_multiple_column_values(
    item_id: 9876543210
    board_id: 1234567890
    column_values: "{\"dependent_on\": null}"
  ) {
    id
  }
}

const query = `
  mutation ($boardId: ID!, $itemId: ID!, $columnValues: JSON!) {
    change_multiple_column_values(
      item_id: $itemId
      board_id: $boardId
      column_values: $columnValues
    ) {
      id
    }
  }
`;

const variables = {
  boardId: 1234567890,
  itemId: 9876543210,
  columnValues: JSON.stringify({
    dependent_on: null
  }),
};

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

Reading column configuration

To understand a dependency column's settings, you can query its settings through the column's 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: ["dependent_on"]) {
      id
      title
      type
      settings
    }
  }
}

`settings` response structure

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

Key	Type	Description
`boardIds`	`number[]`	Array of board IDs the dependency column references. Typically contains the current board's ID.
`dependencyNewInfra`	`boolean`	Whether the column uses the new dependency infrastructure.
`allowMultipleItems`	`boolean`	Whether the column allows multiple dependent items.
`dependency_mode`	`string`	Controls how linked date or timeline columns respond when dependencies change. One of: `flexible`, `strict`, or `no_action`. See Dependency modes for details.

Example `settings` response

{
  "boardIds": [1234567890],
  "dependencyNewInfra": true,
  "allowMultipleItems": true,
  "dependency_mode": "flexible"
}

Dependency modes

The dependency_mode setting determines how the column interacts with a linked Date or Timeline column on the same board when a dependency is marked as done.

Mode	Description
`flexible`	The linked date or timeline shifts automatically, but allows some overlap between the predecessor and successor item.
`strict`	The linked date or timeline shifts automatically and enforces strict sequencing — the dependent item cannot start until its predecessor is fully complete.
`no_action`	No automatic adjustment is made to dates or timelines when a dependency changes state.

📘
The dependency_mode only has an effect when the board contains a Date or Timeline column. Boards without either column behave as if the mode is no_action regardless of the setting.

Get column type schema

You can retrieve the JSON schema for the dependency 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: dependency
  )
}

{
  "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": {
              "boardIds": {
                "type": "array",
                "description": "Array of board IDs for dependencies",
                "items": {
                  "type": "integer"
                }
              },
              "dependencyNewInfra": {
                "type": "boolean",
                "description": "Whether to use new dependency infrastructure"
              },
              "allowMultipleItems": {
                "type": "boolean",
                "description": "Whether to allow multiple items"
              },
              "boardId": {
                "type": "integer",
                "description": "Primary board ID for the dependency"
              },
              "dependency_mode": {
                "type": "string",
                "enum": ["flexible", "strict", "no_action"],
                "description": "Controls automatic date/timeline adjustments when dependencies change"
              }
            },
            "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.