How to Connect Monday CRM to OpenClaw: Workflow Automation Setup

Monday.com teams burn hours each week updating boards by hand: dragging items between groups, changing status columns, pasting notes from calls. OpenClaw eliminates most of that. Write one skill file, and your AI agent reads your Monday CRM pipeline, creates items, updates deal stages, and sends you daily board summaries through Telegram or WhatsApp.

This guide covers the full integration: generating your Monday.com API token, writing an OpenClaw skill that calls Monday’s GraphQL API directly, and building automations for status updates, deadline alerts, and cross-board syncing. If OpenClaw is already running on your machine, expect about 25 minutes from start to finish.

---

What This Integration Does

Your OpenClaw agent becomes a chat-based interface to Monday CRM. Instead of opening the Monday.com UI, switching between boards, and clicking through columns, you message your agent and it handles the GraphQL calls.

Out of the box, the skill covers:

• Look up leads and deals by name, column value, or group
• Check pipeline stages across boards with a single message
• Create and update items without touching the Monday.com interface
• Move items between groups (e.g., from “Qualified Lead” to “Proposal Sent”)
• Get daily pipeline summaries through OpenClaw’s heartbeat scheduling

Monday.com uses a GraphQL API, not REST. That matters because a single GraphQL query can pull a board’s items, their column values, and their group assignments in one call. With REST you would need three separate requests. The skill file you will write takes advantage of this.

---

Before You Start

Three things need to be in place:

1. OpenClaw installed and running. If you have not done this yet, follow our OpenClaw setup guide. That covers installation, workspace configuration, memory, and messaging channel setup.

2. A Monday.com account with API access. Monday.com opened API access across all plans in early 2026, including the free tier. You generate a personal API token from the Developer Center. No paid plan required for core board and item operations.

3. A text editor. VS Code, Cursor, or anything that handles Markdown. You will create one file.

---

Step 1: Get Your Monday.com API Token

Monday.com uses personal V2 API tokens. Your token’s permissions mirror your UI permissions exactly: if you can see a board in Monday.com, the API can access it too.

Generate the Token

1. Log into Monday.com
2. Click your profile picture (bottom left) and select Developers
3. In the Developer Center, click My access tokens
4. Click Show to reveal your personal token, then copy it

If you are an account admin, you can also find tokens under Administration > Connections > Personal API token. Both paths give you the same token.

One thing to know: regenerating a token instantly invalidates the previous one. If you rotate your token later, you will need to update your .env file.

Store the Token

Keep the token out of your skill file. Add it to a .env file:

# ~/.env or ~/openclaw/.env
MONDAY_API_TOKEN=eyJhbGciOiJIUzI1NiJ9.your_actual_token_here

OpenClaw reads environment variables at runtime. This keeps the secret out of any workspace file your agent might log or surface in conversation.

---

Monday.com GraphQL API Basics

Monday.com’s API is entirely GraphQL. If you have only worked with REST APIs (like HubSpot’s), the syntax looks different but the concept is the same: you send a POST request to a single endpoint with a JSON body describing what you want.

Endpoint: https://api.monday.com/v2

Authentication header: Authorization: YOUR_TOKEN (no “Bearer” prefix, unlike most APIs)

Query structure:

query {
  boards(ids: [BOARD_ID]) {
    items_page(limit: 50) {
      items {
        id
        name
        column_values {
          id
          text
          value
        }
        group {
          title
        }
      }
    }
  }
}

This single query returns all items on a board with their column values and group assignments. A REST API would need separate calls for each.

Mutation structure (for creating/updating):

mutation {
  create_item(
    board_id: BOARD_ID,
    group_id: "GROUP_ID",
    item_name: "New Lead - Acme Corp",
    column_values: "{\"status\": {\"label\": \"New\"}, \"date4\": {\"date\": \"2026-04-15\"}}"
  ) {
    id
    name
  }
}

The column_values parameter is a JSON string inside the GraphQL mutation. This trips people up. Column IDs (like status, date4) are specific to your board. You can find them by querying the board’s columns first.

---

Step 2: Write the OpenClaw Monday Skill

OpenClaw skills are Markdown files that teach your agent when and how to call an external API. The skill lives in your workspace’s skills/ directory.

Create the Skill Directory

mkdir -p ~/.openclaw/workspace/skills/monday

Write the SKILL.md File

Create ~/.openclaw/workspace/skills/monday/SKILL.md with this content:

---
name: monday
description: Read and write Monday.com CRM data. Manage boards, items, leads, deals, and pipeline stages via the Monday.com GraphQL API.
tools:
  - shell
---

# Monday.com CRM Skill

## Authentication

Use the environment variable `MONDAY_API_TOKEN` for all API requests.
All requests go to `https://api.monday.com/v2` with these headers:

Authorization: $MONDAY_API_TOKEN
Content-Type: application/json

## Available Operations

### List All Boards

curl -s -X POST "https://api.monday.com/v2" \
  -H "Authorization: $MONDAY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "{ boards(limit: 25) { id name board_kind state } }"}' \
  | jq '.data.boards[] | {id, name, kind: .board_kind}'

### Get Items from a Board

curl -s -X POST "https://api.monday.com/v2" \
  -H "Authorization: $MONDAY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "{ boards(ids: [BOARD_ID]) { items_page(limit: 50) { items { id name column_values { id text value } group { title } } } } }"}' \
  | jq '.data.boards[0].items_page.items'

### Search Items by Name

curl -s -X POST "https://api.monday.com/v2" \
  -H "Authorization: $MONDAY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "{ items_page_by_column_values(board_id: BOARD_ID, limit: 10, columns: [{column_id: \"name\", column_values: [\"SEARCH_TERM\"]}]) { items { id name column_values { id text } } } }"}' \
  | jq '.data.items_page_by_column_values.items'

### Create a New Item

curl -s -X POST "https://api.monday.com/v2" \
  -H "Authorization: $MONDAY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "mutation { create_item(board_id: BOARD_ID, group_id: \"GROUP_ID\", item_name: \"ITEM_NAME\", column_values: \"COLUMN_VALUES_JSON\") { id name } }"}' \
  | jq '.data.create_item'

### Update an Item Status

curl -s -X POST "https://api.monday.com/v2" \
  -H "Authorization: $MONDAY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "mutation { change_column_value(board_id: BOARD_ID, item_id: ITEM_ID, column_id: \"status\", value: \"{\\\"label\\\": \\\"NEW_STATUS\\\"}\") { id name } }"}' \
  | jq '.data.change_column_value'

### Move Item to a Different Group

curl -s -X POST "https://api.monday.com/v2" \
  -H "Authorization: $MONDAY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "mutation { move_item_to_group(item_id: ITEM_ID, group_id: \"TARGET_GROUP_ID\") { id } }"}' \
  | jq '.data.move_item_to_group'

### Get Board Column IDs

Use this to discover column IDs for your specific board:

curl -s -X POST "https://api.monday.com/v2" \
  -H "Authorization: $MONDAY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "{ boards(ids: [BOARD_ID]) { columns { id title type } groups { id title } } }"}' \
  | jq '.data.boards[0]'

## Rules

- Always confirm before creating or updating items. Show the user what will change and ask for approval.
- When searching, try the exact name first. Broaden the search if no results come back.
- For status changes, show the current status and the proposed new status before executing.
- Monday.com rate limits vary by plan. If you receive a 429 response, wait 30 seconds and retry once.
- Never log the API token in responses or memory files.
- When working with column_values, always query the board columns first to get correct column IDs.

What Each Section Does

The frontmatter tells OpenClaw when to activate this skill. When you mention “Monday”, “board”, “pipeline”, or “deal stage”, the agent recognizes it should use this skill.

The operations give the agent GraphQL templates it adapts per request. Ask “What deals are in the proposal stage?” and the agent reads the board query pattern, substitutes your board ID, filters by the status column, and returns the results.

The column discovery query is critical. Monday.com boards have custom columns with auto-generated IDs like status, date4, text0. Without querying the board schema first, the agent would guess column IDs and fail. The “Get Board Column IDs” operation solves this.

The rules set guardrails. The confirmation requirement prevents your agent from silently creating duplicate items or moving deals to wrong stages.

---

Step 3: Test the Connection

Restart OpenClaw to load the new skill:

openclaw gateway restart

Open your Telegram (or WhatsApp, Slack, Discord) chat with your OpenClaw agent and run these tests:

Read test:

“List all my Monday.com boards”

The agent should return board names and IDs. Pick the board ID for your CRM pipeline.

Item lookup test:

“Show me all items on board [BOARD_ID]”

You should see item names, statuses, and group assignments.

Column discovery test:

“What columns does board [BOARD_ID] have?”

This returns the column schema. Note the column IDs for status, date, and any custom fields you use.

Write test (start here):

“Create a new item on board [BOARD_ID] called ‘Test Lead - SFAI’ in the first group”

The agent should ask you to confirm before creating. If it skips confirmation, strengthen the Rules section in your SKILL.md.

If tests fail, check these:

Symptom	Likely Cause	Fix
401 Unauthorized	Token is wrong or expired	Regenerate at Developers > My access tokens
Empty response	Board ID is incorrect	Run the “list boards” query first
Column value errors	Wrong column ID	Run the column discovery query
429 Too Many Requests	Rate limit	Wait 30 seconds, try again

---

MCP Server or Custom Skill: Which to Use

Monday.com released an official MCP server at https://mcp.monday.com/mcp. It provides pre-built tools for item management, board operations, and user queries. You might wonder whether to use that instead of the custom skill above.

Use the MCP server when:

• You want the fastest possible setup (one config line)
• You do not need custom query logic
• You are comfortable with Monday.com controlling the tool definitions

Use a custom skill when:

• You want full control over what queries run and how results are formatted
• You need CRM-specific logic (e.g., “show me deals closing this week with no activity in 3 days”)
• You want to combine Monday.com calls with other tools in a single skill
• You prefer transparency: you can read every GraphQL query in your SKILL.md

For most CRM use cases, the custom skill wins. CRM workflows involve conditional logic (“if deal amount exceeds $50K and stage is Negotiation, alert me”) that pre-built MCP tools do not handle without extra configuration. The custom skill lets you bake that logic directly into the instructions.

---

What to Automate First

Start with read-only operations. Build confidence in the agent’s accuracy before letting it write to your boards.

Week 1: Board Lookups

Use your agent for quick CRM questions throughout the day:

• “What stage is the Acme Corp deal at?”
• “Show me all leads added this week”
• “Who owns the Globex deal?”
• “How many items are in the Proposal Sent group?”

Compare every response against what you see in Monday.com’s UI. This calibration period catches column mapping issues early.

Week 2: Write Operations

Once lookups feel reliable:

• “Move the Acme deal to Contract Sent”
• “Create a new lead: Jane Smith, Initech, estimated value $25K”
• “Update the priority column on the Globex item to High”
• “Add a note to the Acme deal: pricing approved, waiting on legal review”

Week 3: Automated Alerts and Summaries

This is where the integration pays for itself. Add these to your OpenClaw heartbeat or cron configuration.

Stale deal detector (add to heartbeat.md):

## Stale Pipeline Check
Query the Monday CRM board for items that have not changed status in 14 days.
For each stale item, send me a message with:
- Item name and current group
- Days since last status change
- Deal owner
- Estimated value
Sort by value descending.

Morning pipeline brief (cron, 8:00 AM):

## Daily CRM Brief
Pull all items from the Monday CRM board closing in the next 7 days.
For each item, check if it moved to a new group in the last 3 days.
Flag items with no recent movement.
Send summary to Telegram with items grouped by owner.

Cross-board sync (heartbeat):

## Board Sync: CRM to Project Delivery
When an item on the CRM board moves to the "Won" group, check if a corresponding item exists on the Project Delivery board.
If not, create one with the client name, deal value, and expected start date.
Notify me when a new project item is created.

This progression (read, write, automate) follows the same pattern from our HubSpot integration guide. It reduces risk of the agent making unwanted changes to live CRM data.

---

Security Considerations

Your Monday.com token has the same access level as your user account. Every board and item you can see in the UI is accessible through the API.

Least-privilege approach. If you only need CRM board access, consider creating a dedicated Monday.com user with permissions limited to CRM boards. Use that user’s token instead of your admin token.

Token storage. Keep the token in .env, not inside agents.md, soul.md, or any workspace file. OpenClaw reads workspace files into context, and you do not want the token surfaced in conversation.

Confirmation rules. The SKILL.md rules section requires the agent to confirm before writes. This is your safety net against misinterpreted instructions. If you tell the agent “delete the old test items” and it misidentifies which items are “old”, the confirmation step catches that.

Token rotation. Monday.com lets you regenerate tokens anytime. Rotating every 90 days is a reasonable cadence. Remember that regeneration instantly invalidates the current token.

For a deeper look at OpenClaw security practices, see Step 9 of our OpenClaw setup guide.

---

Frequently Asked Questions

Do I need a paid Monday.com plan to use the API?

Monday.com opened API access across all plans in early 2026. Free accounts can generate personal API tokens and query boards, items, and columns. Premium features like workflow automations and advanced board types may require paid plans, but the core CRUD operations this guide covers work on the free tier.

How long does this setup take?

About 25 minutes with OpenClaw already installed. Token generation takes 2 minutes. Writing and saving the skill file takes 10 minutes. Testing with live queries takes another 10-15 minutes. If you need to install OpenClaw first, add 30-45 minutes for the initial setup.

Can OpenClaw update Monday.com boards automatically?

Yes. OpenClaw’s heartbeat scheduling and cron jobs let you define rules that run on a timer. “Every morning, check for stale deals” or “When a deal moves to Won, create a project delivery item” both work without you sending a message. Start with notification-only automations before enabling write operations on a schedule.

What if I hit the Monday.com API rate limit?

Rate limits vary by plan. Most conversational use stays well under the limit. If you run aggressive automated scans on large boards, you might get a 429 response. The skill file’s rules section tells the agent to wait 30 seconds and retry. For high-volume use cases, batch your queries and use the items_page pagination parameter instead of requesting all items at once.

Should I use the Monday.com MCP server or a custom skill?

The MCP server at mcp.monday.com is faster to set up: one configuration line and you have pre-built tools. The custom skill gives you full control over queries, result formatting, and conditional logic. For CRM workflows that involve business rules (deal thresholds, stale pipeline detection, cross-board syncing), the custom skill is more practical. You can also use both: MCP for basic operations, custom skill for CRM-specific automation.

Is it safe to give my AI agent Monday.com access?

As safe as you configure it. Use a dedicated user with limited board permissions, store the token in .env, and require confirmation for write operations. OpenClaw runs on your machine, so data flows directly between you and Monday.com’s servers. The biggest risk is the agent misinterpreting an instruction, which is why the confirmation rule matters. For 24/7 automated workflows, run OpenClaw on a VPS like Hostinger where you control the environment.

---

Key Takeaways

• Connect Monday CRM to OpenClaw by generating a personal API token and writing a SKILL.md with GraphQL query templates
• Monday.com’s GraphQL API lets you pull board items, column values, and group assignments in a single request
• Start with read-only board lookups before enabling write operations or automated workflows
• Store your token in .env and require agent confirmation before any write to your CRM board
• Use heartbeat or cron rules for automated pipeline monitoring: stale deals, daily summaries, and cross-board syncing
• The custom skill approach gives more CRM-specific control than the Monday.com MCP server for pipeline automation