The email column allows you to attach an email address to an item and send emails to that contact with a single click. Each value stores both an email address and a display text label.

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

Column Type	Implementation Type	Supported Operations
`email`	`EmailValue`	Read: Yes Filter: Yes Update: Yes Clear: Yes

Queries

Email columns can be queried through the column_values field on items using an inline fragment on EmailValue.

query {
  items(ids: [1234567890, 9876543210]) {
    name
    column_values {
      ... on EmailValue {
        id
        email
        label
        text
        value
        updated_at
      }
    }
  }
}

const query = `
  query ($itemIds: [ID!], $columnType: [ColumnType!]) {
    items(ids: $itemIds) {
      name
      column_values(types: $columnType) {
        ... on EmailValue {
          id
          email
          label
          text
          value
          updated_at
        }
      }
    }
  }
`;

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

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

Fields

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

Field	Description
column `Column!`	The column the value belongs to, including its `id` and `title`.
email `String`	The email address. Returns `null` if the column is empty.
id `ID!`	The column's unique identifier.
label `String`	The display text label. When the user doesn't set separate display text, this equals the `email` value. Returns `null` if the column is empty.
text `String`	A combined text representation in the format `"label - email"`. Returns `""` if the column is empty.
type `ColumnType!`	The column's type (`email`).
updated_at `Date`	The column's last updated date.
value `JSON`	The column's raw value as a JSON string containing `email`, `text`, and `changed_at` keys. Returns `null` if the column is empty.

Example response

{
  "data": {
    "items": [
      {
        "name": "Task A",
        "column_values": [
          {
            "id": "email",
            "email": "test@example.com",
            "label": "Test Contact",
            "text": "Test Contact - test@example.com",
            "value": "{\"email\":\"test@example.com\",\"text\":\"Test Contact\",\"changed_at\":\"2026-03-21T08:42:31.539Z\"}",
            "updated_at": null
          }
        ]
      }
    ]
  }
}

Filter

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

Operator	Compare Value	Description
`any_of`	An array of display text values (e.g., `["Test Contact"]`)	Returns items whose email column display text matches any of the specified values. Matches the `label` field, not the raw email address.
`not_any_of`	An array of display text values (e.g., `["Test Contact"]`)	Excludes items whose email column display text matches any of the specified values.
`contains_text`	A partial or full string (e.g., `["@example.com"]`)	Returns items where the email address or display text contains the specified string.
`not_contains_text`	A partial or full string (e.g., `["@gmail"]`)	Excludes items where the email address or display text contains the specified string.
`is_empty`	`[]`	Returns items with an empty (unset) email value.
`is_not_empty`	`[]`	Returns items that have an email value set.

📘
The any_of and not_any_of operators match against the column's display text (label), not the raw email address. If the display text equals the email (i.e., the user didn't set separate display text), then the email address will match. Use contains_text if you need to search by the email address specifically.

Examples

Filter by display text

This example returns all items where the email column's display text matches "Test Contact".

query {
  boards(ids: 1234567890) {
    items_page(
      query_params: {
        rules: [
          {
            column_id: "email"
            compare_value: ["Test Contact"]
            operator: any_of
          }
        ]
      }
    ) {
      items {
        id
        name
        column_values {
          ... on EmailValue {
            email
            label
          }
        }
      }
    }
  }
}

Filter by email domain

This example returns all items that contain "@example.com" in their email address or display text.

query {
  boards(ids: 1234567890) {
    items_page(
      query_params: {
        rules: [
          {
            column_id: "email"
            compare_value: ["@example.com"]
            operator: contains_text
          }
        ]
      }
    ) {
      items {
        id
        name
      }
    }
  }
}

import { ApiClient } from "@mondaydotcomorg/api";
const mondayApiClient = new ApiClient({ token: myToken });

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: "email",
  compareValue: ["@example.com"],
  operator: "contains_text",
};

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

Filter by empty values

This example returns all items with an empty email column.

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

Mutations

Update

You can update an email column using change_simple_column_value or change_multiple_column_values. You can send values as simple strings or JSON objects, depending on the mutation you choose.

`change_simple_column_value`

Send both the email address and display text as a single string separated by a space. The first token is the email address; everything after the first space is the display text. Both are required.

mutation {
  change_simple_column_value(
    item_id: 9876543210
    board_id: 1234567890
    column_id: "email"
    value: "example@example.com This is an example email"
  ) {
    id
  }
}

import { ApiClient } from "@mondaydotcomorg/api";
const mondayApiClient = new ApiClient({ token: myToken });

const query = `
  mutation (
    $boardId: ID!,
    $itemId: ID!,
    $columnId: String!,
    $columnValue: String!
  ) {
    change_simple_column_value(
      item_id: $itemId,
      board_id: $boardId,
      column_id: $columnId,
      value: $columnValue
    ) {
      id
    }
  }
`;

const variables = {
  boardId: 1234567890,
  itemId: 9876543210,
  columnId: "email",
  columnValue: "example@example.com This is an example email",
};

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

`change_multiple_column_values`

Send the email and text keys as a JSON object in column_values. Both keys are required.

mutation {
  change_multiple_column_values(
    item_id: 9876543210
    board_id: 1234567890
    column_values: "{\"email\": {\"email\": \"example@example.com\", \"text\": \"This is an example email\"}}"
  ) {
    id
  }
}

import { ApiClient } from "@mondaydotcomorg/api";
const mondayApiClient = new ApiClient({ token: myToken });

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({
    email: {
      email: "example@example.com",
      text: "This is an example email"
    }
  }),
};

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

Set email on item creation

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

mutation {
  create_item(
    board_id: 1234567890
    item_name: "New contact"
    column_values: "{\"email\": {\"email\": \"contact@example.com\", \"text\": \"Main Contact\"}}"
  ) {
    id
    name
  }
}

Clear

You can clear an email column using change_simple_column_value or change_multiple_column_values.

`change_simple_column_value`

Pass an empty string in value.

mutation {
  change_simple_column_value(
    item_id: 9876543210
    board_id: 1234567890
    column_id: "email"
    value: ""
  ) {
    id
  }
}

`change_multiple_column_values`

Pass null in column_values.

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

Reading column configuration

To check an email column's settings, query 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: ["email"]) {
      id
      title
      settings
    }
  }
}

`settings` response structure

The settings field returns a typed JSON object. For a default email column, this will be an empty object {}. When configured, it can contain:

Key	Type	Description
`includePulseInSubject`	`boolean`	Whether to include the item name in the email subject line.
`ccPulse`	`boolean`	Whether to CC the item's email address on outgoing emails.

Example `settings` response (default)

{}

Example `settings` response (configured)

{
  "includePulseInSubject": true,
  "ccPulse": true
}

Get column type schema

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

{
  "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": {
              "includePulseInSubject": {
                "type": "boolean",
                "description": "Whether to include the item name in the email subject"
              },
              "ccPulse": {
                "type": "boolean",
                "description": "Whether to CC the item email address"
              }
            },
            "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.