How to Export Data from Monday.com: API Limits, Methods, Gaps

How to Export Data from Monday.com: API Limits, Methods, Gaps

Monday.com gives you four ways to get data out: board-level Excel/CSV export, full account export, the GraphQL API (v2, cursor-paginated), and third-party connectors like Zapier or Make. Each method has hard limits on what it includes, what it drops, and how much data you can move per day. This guide covers every method with the specific constraints you need to plan around, including rate limit tables, working GraphQL examples, and JSON structure samples for common column types.

API version note: All GraphQL examples in this guide apply to Monday.com API version 2024-01 (stable as of Q1 2025). Monday.com versions its API by release date; pin your integration to a specific version using the API-Version request header to avoid breaking changes.

The four Monday.com export methods, compared

Monday.com data export is the process of extracting board items, column values, updates, files, and account-level data from the Monday.com platform into external formats (Excel, CSV, JSON) or systems. No single method captures everything — you'll likely need to combine at least two.

How to export a single Monday.com board to Excel or CSV

From any board, click the three-dot menu and select More actions → Export board to Excel or Export board to CSV. A dialog lets you choose whether to include updates and subitems.

The export respects active filters — only items matching the current filter are included. This is useful if you only need a subset: filter first, then export. You can also export individual groups or batch-selected items using board actions.

What you get:

• All standard and custom column data: Status, Date, Text, Numbers, Person, Dropdown, etc.
• Updates and replies (if selected during export — every update thread and reply)
• Item-level subitems as child rows

What you don't get:

• File attachments (the .xlsx contains no binary files; the files are not referenced by URL either)
• Subitem updates (parent item updates export; subitem updates do not)
• Auto Number column values (silently omitted)
• Dashboards or cross-board Mirror column references
• The "Powered by monday.com" branding row cannot be suppressed — delete it manually post-export

Enterprise admin note: Account admins on Enterprise plans can activate a permission that disables non-admins from exporting boards to Excel. If the export option is missing for your team, check your Enterprise admin settings under Administration → Security.

Common Excel formatting pitfalls

Opening a raw CSV export by double-clicking it causes Excel to auto-import with wrong delimiters, merge cells, and misparse dates as text. Always use Data → Get Data → From Text/CSV (Power Query) to control delimiter detection, encoding (UTF-8), and column type inference. This is especially important if your board data includes non-ASCII characters or ISO 8601 date strings.

How to export your entire Monday.com account

Monday.com full account export downloads all active boards as a .zip file containing one .xlsx per board. Only account admins can trigger it.

Navigate to Profile picture → Administration → Account → Export, then click Export. Monday.com sends a download link to your admin email address. The export can take up to 24 hours for large accounts. You can trigger the export once every 24 hours.

You can optionally exclude file attachments to reduce export size and processing time by checking the exclusion box before clicking Export.

What the account export excludes

This is where teams get burned. The full account export has significant blind spots:

• Archived boards: The export excludes all archived boards. Most teams archive completed project boards rather than deleting them, meaning years of historical work may be entirely absent from every export you have run.
• Workdocs: Not included. Export individual Workdocs manually as PDF, Word, or Markdown before running the account export — there is no bulk Workdoc export path.
• Dashboards: Not included. Dashboard widget layouts and configurations must be rebuilt manually. The underlying board data is present (via the board exports), but the visual layer is lost.
• Emails & Activities timeline: Not included in the account export.

Critical gap: If your team archives completed project boards — standard practice — your account export is missing potentially years of historical data. Unarchive boards before exporting, or use the API to query archived boards directly by board ID.

Monday.com GraphQL API: the only programmable export path

Monday.com's API is a GraphQL-based interface (versioned, cursor-paginated) that lets you query boards, items, column values, updates, and assets programmatically. The API uses cursor-based pagination to retrieve up to 500 items per request.

How to find a board ID

Every API query against a specific board requires its numeric board ID. Three ways to find it:

1. Open the board in Monday.com. The URL contains the ID: https://yourworkspace.monday.com/boards/1234567890
2. Use the boards query with a name filter: boards(limit: 50) { id name }
3. For archived boards, use: boards(limit: 50, state: archived) { id name }

Paginating through all items on a board

The basic pattern for extracting all items:

# Step 1: First page
query {
  boards(ids: 1234567890) {
    items_page(limit: 500) {
      cursor
      items {
        id
        name
        column_values {
          id
          text
          value
        }
      }
    }
  }
}

# Step 2: Subsequent pages — use next_items_page at the root to reduce complexity cost
query {
  next_items_page(limit: 500, cursor: "your_cursor_here") {
    cursor
    items {
      id
      name
      column_values {
        id
        text
        value
      }
    }
  }
}

items_page nested inside boards carries high complexity cost because the board resolver runs first. For pages 2+, use next_items_page at the query root — it accepts only the cursor and limit, bypassing the board-level resolver and dramatically reducing per-request complexity. Continue paginating until the returned cursor field is null, which indicates the end of the dataset.

Column value JSON structures

Monday.com column values are returned as JSON strings in the value field. The structure differs by column type — parsing them into clean relational data requires type-specific handling. Here are the actual structures for four common types:

Status column:

{
  "index": 1,
  "post_id": null,
  "changed_at": "2024-03-15T10:22:00.000Z"
}

The index maps to a label via the board's column settings — you must query boards { columns { settings_str } } separately to resolve index → label (e.g., 1 → "In Progress").

People column:

{
  "personsAndTeams": [
    {"id": 9876543, "kind": "person"},
    {"id": 1111111, "kind": "team"}
  ]
}

Person IDs must be resolved to names via a separate users(ids: [...]) { id name email } query.

Timeline (Date range) column:

{
  "from": "2024-04-01",
  "to": "2024-04-30"
}

Stored as ISO 8601 date strings. Straightforward to parse; no secondary lookup required.

Mirror column:

null

Mirror columns return null in the value field via the standard column_values query. To retrieve mirrored data, query column_values { ... linked_items { id name } } using the MirrorValue type, which requires knowing the connected board structure.

Key insight: Never rely on the text field alone for programmatic parsing. text is a human-readable string Monday.com generates for display purposes; its format can change without notice. Always parse value (the raw JSON) for reliable data extraction.

How to extract file attachments

Files in Monday.com are stored as assets. Extracting them requires two steps:

Step 1: Query asset URLs

query {
  items(ids: [123456789]) {
    assets {
      id
      name
      url
      file_size
      created_at
    }
  }
}

Step 2: Download each file

The url field returns a pre-signed S3 URL that is valid for a limited time (typically minutes to hours). Download the file using an authenticated HTTP GET request with your API token in the Authorization header:

GET <asset_url>
Authorization: Bearer your_api_token_here

Assets are not included in the account export zip. For a complete file backup, you must query assets per item via the API and download each file individually. For boards with thousands of attachments, budget this as a separate, rate-limit-aware process.

Webhooks as an alternative to polling

Monday.com supports webhooks for event-driven data extraction — an alternative to repeatedly polling the API. Webhooks push a JSON payload to your endpoint when board events occur (item created, column value changed, status updated, etc.).

When to use webhooks instead of polling:

• You need near-real-time data sync (< 1 minute latency)
• Your board has high write volume and polling would exhaust daily API call limits
• You're building a continuous pipeline rather than a one-time export

Webhook limitations:

• Webhooks do not deliver historical data — only events that occur after subscription
• They do not replace bulk export for initial data loads
• Webhook payloads contain item ID and changed values, not full item state; you still need a follow-up API call to fetch complete item data if needed

Register a webhook via the API:

mutation {
  create_webhook(
    board_id: 1234567890,
    url: "https://your-endpoint.com/monday-webhook",
    event: change_column_value
  ) {
    id
    board_id
  }
}

How to check API complexity before running a query

Query complexity defines the computational cost of each API operation. Each API token receives a fixed complexity budget per minute. Exceeding it returns a 429 error. Check the cost of any query by adding the complexity node:

query {
  complexity {
    before
    query
    after
    reset_in_x_seconds
  }
  boards(ids: 1234567890) {
    items_page(limit: 100) {
      cursor
      items { id name }
    }
  }
}

Approximate complexity costs for common operations:

Nested queries grow in complexity multiplicatively. A query requesting boards → items_page → column_values → linked_items can approach the 5,000,000 point single-query ceiling on large boards. Use next_items_page at the root and request only the fields you need to stay within budget.

Monday.com API rate limits by plan

Monday.com enforces six distinct rate limit dimensions. Understanding all of them is required if you're building an export script or integration. All limits are measured per account, per app.

Daily call limits

The daily call limit resets at midnight UTC:

1,000 calls/day on Free, Basic, and Standard is a firm ceiling. A board with 2,000 items requires 4 paginated requests at limit=500 — just to read that one board. A modest bidirectional sync across 10 boards can consume this quota within hours.

Enterprise accounts can purchase additional daily call capacity through the admin section. Each add-on unit adds 25,000 daily API calls.

Complexity limits

Minute and concurrency limits

Rate limit errors return HTTP 429. The response includes a Retry-After header specifying how many seconds to wait before retrying. Monitor the RateLimit response header in real time: the r value shows remaining requests in the current window; the t value shows seconds until reset.

Rate-limit error handling: exponential backoff

The blog mentioning "wait for the number of seconds in t" is insufficient for production use. Implement exponential backoff with jitter:

import time, random, requests
 
def query_monday(payload, token, max_retries=5):
    url = "https://api.monday.com/v2"
    headers = {
        "Authorization": f"Bearer {token}",
        "API-Version": "2024-01",
        "Content-Type": "application/json"
    }
    for attempt in range(max_retries):
        response = requests.post(url, json=payload, headers=headers)
        if response.status_code == 200:
            return response.json()
        elif response.status_code == 429:
            retry_after = int(response.headers.get("Retry-After", 60))
            # Exponential backoff with jitter: base wait + random 0–5s
            wait = retry_after * (2 ** attempt) + random.uniform(0, 5)
            print(f"Rate limited. Waiting {wait:.1f}s (attempt {attempt+1})")
            time.sleep(wait)
        else:
            response.raise_for_status()
    raise Exception("Max retries exceeded")

What counts toward your daily limit

• Standard GraphQL requests: 1 call each
• Rate-limit errors (429 responses): 0.1 calls each
• High-complexity queries: may count as more than 1 call
• MCP tool calls (Monday's AI agent interface): 1 call each, competing with the same daily quota as your custom integration

What happens when you hit the daily limit mid-export

There is no queuing mechanism. Requests made after the daily limit is exhausted return a 429 error with an error body indicating the daily limit has been reached (distinct from the per-minute 429). Your export script must:

1. Track call count against the known plan limit
2. Checkpoint progress (last successfully retrieved cursor) to a durable store (file, database)
3. Resume from the checkpoint at midnight UTC when the limit resets

Design every export script to be resumable from a cursor. Never assume a single run will complete on Free, Basic, or Standard plans for boards with more than ~500 items.

What data can't you export from Monday.com?

No single export method captures everything. Consolidated reference:

Not in any standard export:

• Archived boards (must be unarchived, or queried via API using boards(state: archived))
• Dashboard configurations and widget layouts
• Emails & Activities timeline data

Not in board Excel/CSV export:

• File attachments (no files, no URLs in the export)
• Subitem updates (parent updates are included; subitem updates are not)
• Auto Number column values (silently omitted)
• Mirror column resolved values

Not in account export:

• Workdocs (export individually as PDF/Word/Markdown)
• Archived boards
• Dashboard configurations

API-specific gaps:

• File binary content requires separate asset URL queries + authenticated downloads
• Activity log exports show only column value changes — item creation, deletion, and movement are not captured
• Mirror column value field returns null; requires MirrorValue type query with linked board context

Activity log retention by plan

This retention limit is a hard data boundary. If you are on a Pro plan and haven't exported activity logs in over a year, that data is permanently gone. Export activity logs on a scheduled basis, not just during migrations.

How to export Monday.com data using third-party tools

Zapier works well for event-driven exports — appending a row to Google Sheets or creating a record in Airtable when a Monday.com item changes. It is trigger-based, not query-based, making it unsuitable for bulk initial exports of existing data. Zapier has no native mechanism to paginate through all existing board items.

Make (formerly Integromat) offers an "Execute a GraphQL Query" module with direct API access and visual iteration orchestration. You can build a scenario that calls items_page, stores the cursor, loops through next_items_page calls, and writes results to Google Sheets or a database — without writing code. Make is the strongest no-code option for paginated bulk exports. The cursor pattern (store cursor between iterations, pass it to the next call) is natively supported via Make's iteration and variable modules.

Unito specializes in ongoing bidirectional sync rather than one-time exports. It maps Monday.com item fields to destination tool fields (e.g., Google Sheets columns) and maintains sync in near-real time. It is not designed for bulk migration or one-time data dumps.

Plan limits matter: Third-party integrations count against Monday.com API call quotas just like direct API calls. On Free/Basic/Standard plans, a Make scenario doing a full board sync plus a Zapier automation running concurrently can exhaust 1,000 daily calls before noon. Audit total API consumption across all integrations, not just your custom scripts.

Practical export strategy for large Monday.com accounts

For accounts with hundreds of boards and thousands of items — migration, compliance backup, or analytics — this sequence minimizes risk and API cost:

1. Start with the full account export to get a baseline zip of all active boards. Zero API cost; covers all non-archived boards in one operation.

2. Identify gaps systematically. Query the API for archived boards: boards(limit: 50, state: archived) { id name }. Cross-reference against your workspace inventory. Note file-heavy boards, Workdocs, and boards with Mirror columns that need special handling.

3. Use the API for everything the account export misses. Target archived boards by ID, download file assets via authenticated URL fetches, and extract activity logs within your plan's retention window. Prioritize activity log extraction — it has the hardest expiry deadline.

4. Respect rate limits by design, not reaction. Calculate query complexity during development. Spread initial sync calls evenly across the minute window rather than bursting. Checkpoint all progress against cursors. On Pro (10K calls/day at 500 items/request), you can extract approximately 5,000,000 items per day — sufficient for most accounts. On Basic (1K calls/day), plan for multi-day extraction windows.

5. Validate column types after export, especially before re-import. When creating a new board from an import file, Monday.com reads only the first 50 columns. Columns beyond position 50 are silently dropped — no warning, no error. If you're re-importing extracted data, verify column count and order before import.

6. Parse column values by type, not by text field. Build a type-specific parser for Status (index → label lookup), People (ID → name lookup), Timeline (ISO date range), and Mirror (linked item query) columns. Relying on the text display string will produce inconsistent results as column labels change.

For ongoing backup: Monday.com officially partners with Rewind, which provides automated daily backups with granular item-level restore. If your compliance requirements demand continuous backup beyond the 24-hour manual export cycle, evaluate Rewind before building a custom solution.

When to bring in help

Most teams can handle a one-off board export themselves. Scenarios where complexity compounds:

• Multi-board migrations with cross-board dependencies, Mirror columns, and connected board references — these relationships do not survive a round-trip through Excel
• Large-scale exports on lower-tier plans — hitting the 1,000 daily API call ceiling requires multi-day pagination strategies with cursor checkpointing
• Format transformation — Status, People, Timeline, and Mirror column JSON structures each require different parsing logic to produce clean relational data
• File attachment extraction — downloading thousands of assets via pre-signed URLs requires rate-aware parallelism and retry logic
• Preserving subitem relationships — subitems, linked items, and Mirror references require multi-query assembly that the built-in export cannot produce

At ClonePartner, we build custom extraction pipelines for these scenarios — accounts with 500+ boards, complex column structures, and file attachment requirements that the built-in export drops entirely. If your export needs exceed what the three-dot menu handles, we can help.