Documentation / Connectors

Monday.com

Connect Monday.com work-management boards to Nexus over GraphQL with read and write. Filters and ordering push down to Monday's native ItemsQuery rules; aggregation runs in the Nexus engine, and computed columns are non-writable.

The Monday.com connector (bundle version 2.0.6) lets you read from and write to Monday work-management boards through Nexus's standard query and pipeline interfaces. It talks directly to the Monday GraphQL API, translating UQL queries into typed GraphQL operations without ever pulling all board data into your tenant first.

This page is for engineers integrating Monday boards. It covers how boards and groups map to Nexus concepts, the exact operator set (which differs from the SQL adapters — it adds $not_contains/$not_empty and lacks $in/$expr), the filter-and-order pushdown boundary with in-engine aggregation, write semantics including which column types are silently non-writable, and the current pagination and rate-limit constraints.

The pushdown boundary, up front

Monday's GraphQL API can filter and order via ItemsQuery rules but has no aggregation surface. The adapter therefore declares filter and order pushdown only:

Your WHERE conditions translate to ItemsQuery rules and your ordering to Monday's sort — both evaluated by Monday.
GROUP BY and aggregate expressions are evaluated by the Nexus engine after items are fetched, bounded by the post-process row budget.
Design queries to filter to the smallest useful row set before aggregating.

How Monday data maps to Nexus concepts

Nexus concept	Monday concept
Container	Board ID
Collection	Group ID (optional)
Row	Item (flattened to key/value columns)

When you specify a collection, the connector passes it as a group filter in the ItemsQuery. If you omit the collection, the query runs board-wide. Subitems are not exposed as a separate collection and are not included in query results.

Authentication

The connector authenticates with a Monday personal or account API token, stored in your tenant Key Vault and never embedded in pipelines or query definitions.

Secret key	Required	Notes
`monday.api_key`	Yes	Personal or account API token
`monday.api_version`	No	Defaults to `2026-01`

The token is sent as a raw Authorization header value with no Bearer prefix, which is the format Monday's API requires. See Secrets for storage and rotation.

Capabilities

Capability	Supported
Read	Yes
Write (insert / update / delete)	Yes
Merge (upsert)	No
Schema discovery	Yes
`WHERE` filter pushdown	Yes — translates to `ItemsQuery` rules
Order-by pushdown	Yes
Aggregation / `GROUP BY` pushdown	No — aggregate in the Nexus engine

Supported filter operators

Filters in your UQL WHERE clause are translated to Monday ItemsQuery rules. The operator set differs from the SQL-backed adapters — it adds $not_contains and $not_empty, and omits $in, $not_in, $like, and $expr.

UQL operator	Monday rule operator	Notes
`$eq`	`any_of`
`$ne`	`not_any_of`
`$gt`	`greater_than`
`$gte`	`greater_than_or_equal`
`$lt`	`lower_than`
`$lte`	`lower_than_or_equals`
`$contains`	`contains_text`
`$not_contains`	`not_contains_text`
`$starts_with`	`starts_with`
`$ends_with`	`ends_with`
`$empty`	`is_empty`	No compare value needed
`$not_empty`	`is_not_empty`	No compare value needed
`$between`	`between`	Pass a `[low, high]` pair

Operators not listed — including $in, $not_in, $like, and $expr — are not supported by this connector. Using an unsupported operator raises an error at query time rather than silently ignoring the filter. Multiple WHERE conditions are combined with an AND rule operator in the resulting ItemsQuery.

Write operations

The connector supports insert, update, and delete. There is no upsert (merge).

Insert maps record keys to Monday column IDs and creates an item via the create_item mutation.
Update applies column-value changes to an existing item via change_multiple_column_values.
Delete removes an item via delete_item.

Non-writable (computed) columns are skipped

Column types that Monday treats as computed or system-managed are non-writable and are automatically skipped during insert and update. These include formula, auto_number, lookup, creation_log, last_updated, item_id_column, subtasks, button, and dependency. Attempts to write to these column types are silently dropped rather than raising an error — a formula or lookup value is derived by Monday, so Nexus never tries to set it. Plan your writes around the mutable columns; if a value you expected to change did not, confirm it is not one of these computed types.

This writability gate is a per-adapter control, layered beneath the tenant RBAC that governs whether the caller may write at all.

Using the connector in a pipeline

A pipeline reading from a Monday board, aggregating in-engine, and staging to the workspace:

async def run(ctx):
    # Read items from a board, filtered to a status column (pushed to ItemsQuery)
    items = await ctx.read(
        bridge="monday-production",
        containers=["1234567890"],          # board ID
        collection="group_abc123",          # optional group ID
        where={"status": {"$eq": "In Progress"}},
        limit=200,
    )

    # Aggregate in-engine (pushdown not available on Monday)
    by_owner = {}
    for item in items.rows:
        owner = item.get("owner") or "unassigned"
        by_owner[owner] = by_owner.get(owner, 0) + 1

    await ctx.workspace.upsert("monday_owner_summary", list(by_owner.items()))
    ctx.logger.info("Processed %d items", len(items.rows))

No raw credentials appear in the pipeline — the connector resolves the API key from Key Vault at runtime.

Schema discovery

The discover operation enumerates all boards visible to the configured API token, along with their groups and column definitions. Use it to inspect column IDs — needed when mapping field names to write operations — without consulting the Monday interface directly.

Limits & behavior notes

Single-page fetch. The connector issues a single request per query up to the configured limit (default 500 items per request). Cursor-based pagination across boards with more items than the per-request limit is not yet handled — a query that would return more rows than the limit is silently truncated to the limit. For large boards, filter server-side to stay within one page.
Subitems are invisible. Subitems are not exposed and are not included in read or discover results.
Complexity/rate limits are Monday's. Monday's GraphQL API enforces per-call and rolling complexity budgets. The connector does not currently track or back off on complexity consumption; boards with many columns or large result sets can hit rate-limit errors during heavy use.
Computed writes are silent no-ops. As above — writes to formula/lookup/etc. are dropped without error.
No $in/$expr. If you need set membership or raw expressions, filter in-engine after a broader board query, or restructure the board filter.

For boards that fit within a single page, this connector is production-ready for both read and write workloads.