Gentic monday.com — Documentation
Connect any AI agent to your monday.com boards. Read any board the connection can see — its columns, groups, and items — then create items, update fields, move items between groups, and leave updates on the boards you allow. Keep your marketing calendar current, log press and award moments as they happen, and keep a customer-feedback tracker moving, all through the Model Context Protocol.
1. Getting Started
Sign Up & Get Your API Key
Before you can use Gentic monday.com, you need an API key to authenticate your requests.
- Go to gentic.co/monday and create an account.
- Create an organization from your dashboard. API keys and billing are scoped to the organization.
- Generate an API key and use it as a Bearer token in your MCP client.
2. Connecting to the MCP Server
The server is available at https://mcp.gentic.co/monday. For Claude Code:
claude mcp add gentic-monday \
--transport http \
https://mcp.gentic.co/monday \
--header "Authorization: Bearer YOUR_API_KEY"For Claude Web and ChatGPT you can also connect via OAuth — no API key needed. See the connect section on the landing page for other MCP clients (n8n, OpenClaw).
3. Agent Skill
For the best results, pair the MCP server with the Gentic monday.com agent skill. The MCP server gives your agent tool access; the skill teaches it the optimal workflow order. Both the raw SKILL.md and a ready-to-upload .skill bundle are generated on demand from the live manifest, so they always reflect the current tools and pricing.
Add the skill directly via URL:
https://gentic.co/monday/SKILL.mdOr upload a .skill bundle to Claude Managed Agents:
https://gentic.co/monday/gentic-monday.skillDownload this file and upload it wherever Claude Managed Agents asks for a .skill file. It's a zip bundle generated on demand from the latest SKILL.md.
4. Tool Reference
8 tools, rendered live from the Gentic MCP manifest. Parameter tables come directly from each tool's JSON Schema.
monday_add_update
Post an update (a comment, shown in the item's Updates panel) on a monday.com item — the way to leave a note, a summary or a question for the team without overwriting any field. Returns `{ success, update_id, item_id, board_id }`. The body may use simple HTML (<p>, <b>, <ul><li>, <a href>). Only boards in this organization's writable list can be changed (Gentic dashboard → Integrations → monday.com); any other board is refused before anything is sent. Changes appear in monday.com under the name of the person whose token was connected.
| Parameter | Type | Description |
|---|---|---|
item_idrequired | string | The item to post on (from monday_query_items). |
bodyrequired | string | The update text. |
monday_connection_status
Check whether this organization has connected monday.com. Returns `{ connected, account_slug, user_name, writable_board_ids, updated_at }` — `writable_board_ids` are the boards the monday write tools may change (set in the Gentic dashboard → Integrations → monday.com); reading is never restricted. Returns `{ connected: false, hint }` when not connected. Never returns the token. Set check_live to true to also verify the token with one `me` query.
| Parameter | Type | Description |
|---|---|---|
check_live | boolean | When true, make one `me` query to verify the stored token works. |
monday_create_item
Create one item on a monday.com board, e.g. log a press mention on a press-log board or add a launch to a marketing calendar. Returns `{ success, item_id, name, board_id, url }`. `column_values` is an object keyed by COLUMN ID (from monday_get_board_schema — ids are opaque, never guess them), one value per column in that column type's WRITE format: status `{ "label": "Done" }` (a label name from the schema) or `{ "index": 1 }` (its id); date `{ "date": "2026-10-20" }`; timeline `{ "from": "2026-10-20", "to": "2026-10-27" }`; link `{ "url": "https://…", "text": "Coverage" }`; long_text `{ "text": "…" }`; text a plain string; dropdown `{ "labels": ["Email"] }`; people `{ "personsAndTeams": [{ "id": 123, "kind": "person" }] }`; board_relation `{ "item_ids": [123] }`. NOTE the `value` monday_query_items returns is the READ shape and differs — a status reads back as `{ index, changed_at }`, a dropdown as `{ ids }` — so do not echo a read value back as a write. Omit group_id to use the board's top group. Only boards in this organization's writable list can be changed (Gentic dashboard → Integrations → monday.com); any other board is refused before anything is sent. Changes appear in monday.com under the name of the person whose token was connected.
| Parameter | Type | Description |
|---|---|---|
board_idrequired | string | Board to create the item on. |
group_id | string | Group (from monday_get_board_schema) to file it under. |
namerequired | string | The item's name. |
column_values | object | Values keyed by column id; see the formats in the tool description. |
monday_get_board_schema
Get a monday.com board's structure: `{ board: { id, name, board_kind, workspace, writable }, columns: [{ id, title, type, labels?, linked_board_ids? }], groups: [{ id, title }] }`. Column ids are opaque (e.g. `color_mktkmyvv`) and cannot be guessed, so call this BEFORE monday_create_item / monday_update_item: it gives the column ids, the allowed `labels` of status and dropdown columns, and the group ids to file items under. `linked_board_ids` is set for board-relation (connect boards) columns.
| Parameter | Type | Description |
|---|---|---|
board_idrequired | string | The board id, from monday_list_boards. |
monday_list_boards
List the monday.com boards this organization's token can see: `{ boards: [{ id, name, board_kind, items_count, workspace: { id, name }, writable }], page, next_page }`. `writable` says whether the monday write tools may change that board. Every board with subitems has a hidden shadow board named "Subitems of <board>"; those are left out unless include_subitem_boards is true. `name_contains` filters the page that was fetched (case-insensitive) — if `next_page` is not null, more boards exist; call again with `page: next_page` to keep looking. Use the board `id` with monday_get_board_schema, monday_query_items and monday_sync_board.
| Parameter | Type | Description |
|---|---|---|
name_contains | string | Case-insensitive substring of the board name, e.g. "calendar". |
workspace_id | string | Only boards in this workspace (id from a previous listing). |
include_subitem_boards | boolean | Include the "Subitems of …" shadow boards. Default false. |
limit | integer | Boards per page (default 100). 1 – 100 |
page | integer | Page number, starting at 1 (default 1). 1 – 9007199254740991 |
monday_query_items
Read items from one monday.com board, live: `{ board: { id, name }, items: [{ id, name, group: { id, title }, created_at, updated_at, column_values: { <column_id>: { title, type, text, value } }, subitems: [{ id, name }] }], next_cursor }`. `text` is what the monday UI shows; `value` is monday's JSON. Optional `group_id` restricts to one group; optional `rules` filter on column values (monday's query_params rules, e.g. `[{ column_id: "status", compare_value: ["Done"], operator: "any_of" }]`). Up to 100 items per call (default 50); pass `next_cursor` back as `cursor` for the next page (monday expires cursors after 60 minutes; a cursor already carries the original group and rules). Nothing is stored — for analysis over a whole board, use monday_sync_board and query the `monday_items` table.
| Parameter | Type | Description |
|---|---|---|
board_idrequired | string | The board id, from monday_list_boards. |
group_id | string | Only items in this group (id from monday_get_board_schema). |
rules | object[] | Column-value filters, all of which must match. Array item fields column_idstringrequired Column id from monday_get_board_schema. compare_valuearrayrequired Values to compare against, e.g. ["Done"] or a status label index [1]. operatorstringmonday operator, e.g. any_of (default), not_any_of, is_empty, is_not_empty, greater_than, lower_than, between, contains_text. |
limit | integer | Items per call (default 50, max 100). 1 – 100 |
cursor | string | `next_cursor` from a previous call on the same board. |
monday_sync_board
Copy whole monday.com boards into this organization's data backend for analysis — READ-ONLY, one BOUNDED chunk per call. Every item lands in ONE table, `monday_items` (board_id, board_name, item_id, item_name, group_id, group_title, created_at, updated_at, column_values JSON keyed by column id with { title, type, text, value }, subitem_ids, raw, synced_at), upserted on (board_id, item_id) so re-syncs refresh rows in place. Query it with query_data, e.g. `column_values->'$.<column_id>'->>'text'` — that is how to join a marketing calendar's go-live dates against orders or ad spend. BOUNDED + RESUMABLE: each call stops after `max_pages_per_run` pages (500 items each) or `max_seconds_per_run` seconds and returns `has_more` + `next_cursor`; call again with that `cursor` and the same `board_ids` until `has_more` is false. Resume within 55 minutes — monday expires its cursors after 60, and an expired cursor is refused with a restart instruction (restarting is safe: rows are upserted). Items deleted in monday are NOT removed from the table. Returns `{ synced: { <board_id>: count }, has_more, next_cursor, persisted, pages_fetched, not_found, stalled }`.
| Parameter | Type | Description |
|---|---|---|
board_idsrequired | string[] | Boards to copy, in order (ids from monday_list_boards). |
max_pages_per_run | integer | Cap on pages fetched this call (default 20, hard max 50). 1 – 50 |
max_seconds_per_run | integer | Wall-clock budget in seconds (default 60, hard max 120). 1 – 120 |
cursor | any | `next_cursor` from the previous call, passed back unchanged. Omit to start from the first board. |
monday_update_item
Change an existing monday.com item: set column values and/or move it to another group (e.g. move a request from "Backlog" to "In Progress"). Pass at least one of column_values or group_id. Returns `{ success, item_id, board_id, applied: ["column_values" | "group"], url }`. Only the columns you pass change. `column_values` is an object keyed by COLUMN ID (from monday_get_board_schema — ids are opaque, never guess them), one value per column in that column type's WRITE format: status `{ "label": "Done" }` (a label name from the schema) or `{ "index": 1 }` (its id); date `{ "date": "2026-10-20" }`; timeline `{ "from": "2026-10-20", "to": "2026-10-27" }`; link `{ "url": "https://…", "text": "Coverage" }`; long_text `{ "text": "…" }`; text a plain string; dropdown `{ "labels": ["Email"] }`; people `{ "personsAndTeams": [{ "id": 123, "kind": "person" }] }`; board_relation `{ "item_ids": [123] }`. NOTE the `value` monday_query_items returns is the READ shape and differs — a status reads back as `{ index, changed_at }`, a dropdown as `{ ids }` — so do not echo a read value back as a write. To leave a note instead of changing fields, use monday_add_update. Only boards in this organization's writable list can be changed (Gentic dashboard → Integrations → monday.com); any other board is refused before anything is sent. Changes appear in monday.com under the name of the person whose token was connected.
| Parameter | Type | Description |
|---|---|---|
board_idrequired | string | The board the item is on. |
item_idrequired | string | The item to change (from monday_query_items). |
column_values | object | Values keyed by column id; see the formats in the tool description. |
group_id | string | Move the item to this group (id from monday_get_board_schema). |
5. Pricing
Pricing is pulled live from the Gentic MCP manifest. All prices are per call and deducted from your Gentic credits.
| Tool | Cost |
|---|---|
| monday_add_update | Free |
| monday_connection_status | Free |
| monday_create_item | Free |
| monday_get_board_schema | Free |
| monday_list_boards | Free |
| monday_query_items | Free |
| monday_sync_board | Free |
| monday_update_item | Free |
6. Notes
- Organization-scoped: the monday.com token comes from the org's connected integration (Gentic dashboard → Integrations → monday.com). The agent never handles it.
- Reads cover every board the token can see; writes are limited to the writable board IDs set in the dashboard. An empty list means reads only, and the dashboard card says so.
- v1 uses a personal monday.com token, which carries that user's full permissions — and actions appear in monday.com as that user.
- Always read `monday_get_board_schema` before writing: column and group IDs, not titles, address writes, and status/dropdown values must match an existing label.
- monday.com rate-limits by a per-minute budget shared by everything using the token. If a call is rate-limited, wait the number of seconds it reports (`retry_in_seconds`) before retrying. If the account's daily API call limit is used up, don't retry: it resets at 00:00 UTC.
7. When to Apply
- User wants to add an item to a monday.com board — a marketing-calendar entry, a press or award moment, a feedback item.
- User wants to update an item's fields on a monday.com board, or move it to another group (e.g. a new status stage).
- User wants to leave a note or update on a monday.com item without overwriting its fields.
- User wants to find a monday.com board, or see its columns, groups, and status labels.
- User wants to read or filter the items on a monday.com board.
- User wants to sync a monday.com board into their Brain to analyze it with query_data (e.g. calendar go-live dates against sales or ads).
- User asks whether monday.com is connected, or which boards Gentic may write to.
8. Workflow
1. Check the connection first with `monday_connection_status`
Call `monday_connection_status` before anything else. It reports whether a monday.com token is connected, whose it is (`account_slug`, `user_name`), and which boards the write tools may change (`writable_board_ids`); pass `check_live` to verify the token against monday.com right now. If it is not connected, tell the user to connect it in the Gentic dashboard (Integrations → monday.com) rather than guessing. Actions taken through a personal token appear in monday.com as that user — say so when you write.
2. Find the board with `monday_list_boards`
List the boards the connection can see, optionally filtered with `name_contains` or `workspace_id`. Each board's `id` is the `board_id` for every other tool, and `writable` says whether the write tools may change it. `name_contains` filters only the page that was fetched: if `next_page` is not null, call again with `page: next_page` before concluding a board doesn't exist. The hidden "Subitems of …" shadow boards are left out unless you pass `include_subitem_boards`.
3. Read the structure with `monday_get_board_schema` before writing
`monday_get_board_schema` returns a board's columns (`id`, `title`, `type`, and the allowed `labels` for status and dropdown columns) its groups (`id`, `title`), and whether the board is `writable`. Writes are keyed by column ID and group ID, not by titles, and a status or dropdown value must be one of its labels, so always read the schema first instead of guessing IDs.
4. Read items with `monday_query_items`
Pass a `board_id`, and optionally a `group_id` or filter `rules`, to read items live with their column values keyed by column ID (`text` is what the monday.com UI shows, `value` is monday's JSON). Up to 100 items per call (default 50); pass `next_cursor` back as `cursor` for the next page — it already carries the original group and rules, and monday.com expires it after 60 minutes. Nothing is stored; for analysis over a whole board, use `monday_sync_board`.
5. Write on writable boards only: `monday_create_item`, `monday_update_item`, `monday_add_update`
`monday_create_item` adds an item (to the board's top group unless you pass `group_id`) with `column_values` keyed by column ID, each in that column type's WRITE format (e.g. a status `{"label":"Done"}`, a date `{"date":"2026-10-20"}`, a timeline `{"from":…,"to":…}`). The `value` that `monday_query_items` returns is the READ shape and differs — a status reads back as `{ index, changed_at }` — so never echo a read value back as a write. `monday_update_item` changes an item's column values and/or moves it to another group. `monday_add_update` posts a note on an item — prefer it to overwriting a field when you're adding context. **Writes only work on the board IDs the user listed as writable in the dashboard.** If a write is refused for that reason, do not retry or try another board: tell the user which board it was and that they can add it under Integrations → monday.com → Edit boards.
6. Sync for analysis with `monday_sync_board`
`monday_sync_board` copies whole boards (`board_ids`, up to 20) into the per-org `monday_items` table, read-only and one bounded chunk per call. While `has_more` is true, call it again with the returned `next_cursor` and the same `board_ids`, within 55 minutes — monday.com expires its cursors after 60, and an expired cursor is refused with a restart instruction (restarting is safe: rows are upserted, so re-syncing refreshes items in place). Items deleted in monday.com are not removed from the table. Then use `query_data` over `monday_items` — e.g. `column_values->'$.<column_id>'->>'text'` — for counts, date joins, and cross-source questions. Reads and syncs are not limited by the writable-board list.
7. Confirm what changed
After a write, tell the user exactly what happened — the board, the item, which fields changed or which group it moved to, and a link to the item when one is returned. Don't dump raw JSON.