to help teams work better. We are giving away
over $180,000 in prizes including a Tesla S!
API V2 Documentation
Introduction
Welcome to monday.com, a collaborative work management platform. monday.com can help you and your team plan and keep track of all tasks or projects, communicate with one another more effectively, and increase transparency amongst your team.
monday.com’s mission is to help teams fulfill their potential and collaborate better. The monday.com API is one of the ways to help your team achieve more together!
What is the monday.com API exactly?
The monday.com API supports read and write (mutating) access to boards, items, and more. It gives you the ability to both view and use any data you have in monday.com outside of the platform. You can use the API to import external data into your monday.com account or trigger actions in monday.com in response to a change in an external software or service.
We’re also working on adding an “app market place” into the monday.com platform. This would give you the ability to build and add entire applications into monday.com. These apps would then be available for all monday.com users to integrate into the platform. This option is not yet supported but it is in our roadmap. If you plan on building a full app, that others can also use within monday.com, please contact us at support@monday.com
How does it work?
The monday.com API is based on the GraphQL structure (an alternative to REST based API), which operates on a single URL/endpoint. The monday.com API v2 url is: api.monday.com/v2. As a result, you can use the API to pull and/or alter data about Users, Updates, Items, Boards, Tags and more.
How to get started?
Set up a monday.com account
If you’re not already a monday.com user, the first step is to sign up and create your account.
Authenticate with the API
Once you set up your account, the next step to setting up the API is to authenticate with the Access Tokens. For more information, see the authentication section below.
Using the API
If you are already familiar with the monday.com building blocks, check out our API playground to explore our GraphQL schema. If you’re new to the monday.com API, it’s best to start by learning the basics about Boards, Items, Updates, Users, and Tags.
All requests should be POST requests to our API endpoint, with the query string inside the request body. All queries, including mutations, should be sent in the "query" key. All requests except file uploads must set the content-type header to "application/json".
Your JSON request body should look like this:Code example
{ "query": "query {...}," "variables": {"var1":"value1", "var2":"value2", ...} }
Code examples in different programming languages can be found in our Developers Community.
A simple example of how to access monday.com API using a CURL command:
curl -X POST -H "Content-Type:application/json" -H "Authorization:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" -d '{"query":"{boards(limit:1){id name}}"}' "https://api.monday.com/v2/"
Developer Mode
You can use monday.labs to activate "Developer mode" to see template IDs and column IDs:
How to get help?
If you need further support with our API or apps platform, check out our monday.com community. There are a ton of helpful resources and threads in the community, and it’s a great place to connect with other monday.com users with similar use cases.
The community is managed by members of the monday.com team, but not every topic is guaranteed to get a response from our team.
Our Customer Experience team is here to help with:
- Bug reports
- Feature feedback
- Any issue that deals with sensitive information not suitable for the public community
Webhooks
If your application needs real-time updates from monday.com boards, you can use our webhooks. They're great for being notified when something changes on your boards, instead of needing to poll the API constantly. To learn more about creating webhooks through monday.com, click here. To learn more about creating webhooks through our API click here.
Authentication
Before you can start querying the monday.com account with the API, you’ll need to provide valid authentication through an access token. Each user has their own API token, which grants API access to all the boards to which the user has access (i.e they’re subscribed to).
API v2 Token & API Tokens
Currently, monday.com has two active APIs - our “old” (REST-based) and our “new” one (GraphQL). We will gradually deprecate the old version, but for now both of them are available and have different tokens. When using our GraphQL API make sure you’re using the right token which is available under “API v2 Token”.
Accessing your tokens
- Log into your monday.com account.
- Click on your avatar (picture icon) in the bottom left corner.
- Select Admin from the resulting menu (this requires you to have admin permissions).
- Go to the API section.
- Generate a “API v2 Token”
- Copy your token.
*You can always regenerate a new token. Keep in mind it will cause the existing one to expire.
Using tokens
Once you retrieve the token from your monday.com account, you can start making requests with the API. You will need to pass the token to the API in the header of your requests.
Send the API v2 token in the "Authorization" header:
"Authorization:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
Rate Limits
The API rate limits are based on the complexity of each query made, a single query is limited to 5,000,000 complexity points and 10,000,000 / minute per account is the rate limit.
Complexity levels are calculated based on the query. Each call will have a different level of complexity depending on the structure of the query. To keep your query complexity low only ask for the objects and properties you need and use pagination .
For example, a query for all boards and all users would be calculated by adding together the complexity levels of each of those queries.
For example, a query for all boards and their items returns 1000 boards and 1000 items per board. Complexity would be calculated by multiplying 1000x1000 to get a complexity of 1,000,000.
Rates defaults
Certain queries have default complexities regardless of the results of the query. For example, querying most objects without limits (i.e all boards, items, groups etc.) is calculated as a complexity of 1000. However, there are specific objects, like updates, which have a default complexity of 25.
What happens when exceeding the limit?
The complexity limit starts at 10,000,000 and decreases with each query. Each minute the complexity limit resets to 10,000,000. If an account exceeds the limit in a given minute, the query will return an error in the "errors" field.
Complexity limiting
To work efficiently and avoid reaching the limit, it’s recommended to add limits to each part of the query to extract only the data you need and lower the complexity level.
Following up on the example above, you could limit the boards to certain IDs which will decrease the number of results significantly.
Complexity nesting
Multiple nesting will also increase the level of complexity in a query. Currently, the maximum number of nested queries allowed is 6.
When calculating complexity of nested queries, the complexity level of each query will be multiplied together. As a result, it is very important to add limits to each query to prevent exceeding the complexity limit.
Finding out complexity level
Since accounts are limited by complexity level per minute, understanding the complexity level of each query plays a large role in planning the right queries. The best way to calculate the complexity is to query for complexity as part of your queries.
To see how to query complexity, please see the Querying complexity section.
Using GraphQL
Unlike REST APIs where there is a clearly defined structure of information returned from each endpoint, GraphQL always exposes one endpoint, allowing you to determine the structure of the data that is returned.
The result of each query will be formatted in the same way as the query itself.
In the following section we’re going to have a quick look into to GraphQL components.
For a deep-dive into what you can do with GraphQL, check out the GraphQL Foundation's incredible introduction here.
Operations
Query - A GraphQL query performs the READ operation and does not change data.
Mutation - To perform all other operations to modify data you will need mutations. You can think of mutations as CUD (Create, Update, Delete) in REST.
Object Types
Object types are a collection of fields, which are used to describe the set of possible data you can query from the API.
Fields
Fields are used to ask for specific properties in objects.
Each object has fields that can be queried by name in order to query for specific properties.
Arguments
You can pass arguments to a query to determine the return value (eg. filtering search results) and narrow down the results to the specific ones you’re after.
In the following example, the object is “boards”, the requested field is “title”, the argument is “ids”, and the argument value is 157244624.
GraphQL visual interface - GraphiQL
One of the most powerful parts of GraphQL is its visual interface. GraphiQL is an in-browser tool for writing, validating, and testing GraphQL queries.
Before diving in and starting querying the API, it’s highly recommended to run your queries through the visual interface to make sure they are correct and the data being returned is the data you expect. GraphiQL is available in the Try It Yourself tab.
Variables
Variables can be used to pass dynamic values to our arguments. Variables are written outside of the query string itself, in the variables section, and passed to the arguments.
When we start working with variables, we need to do three things:
- Replace the static value in the query with $variableName
- Declare $variableName as one of the variables accepted by the query
- Pass variableName: value in the separate, transport-specific (usually JSON) variables dictionary
Errors supported by Monday GraphQL API
Our GraphQL API returns the set of predefined errors, which are listed here. All the handled exceptions are returned with the status 200 and next structure
Code example
{ "error_code": "SomeKindOfException", "status_code": 200, "error_message": "Some error happened", "errorData": {...} }
401 - Unauthorized (Not authenticated)
Ensure your API key is valid and passed in the “Authorization” header.
400 - Bad Request (No query string was present)
Ensure your query string is passed with the “query” key. Ensure your request is a POST with JSON body. Ensure your query does not contain unterminated strings.
500 - Internal Server Error (No query string was present)
Check the format of any JSON strings in your query. If you are updating a column, check that you are using the right data structure for each column value.
Parse error on...
Ensure your query is a valid string, and all parens and braces are balanced.
200 - UserUnauthroizedException (User unauthorized to perform action)
Check if the user has permission to access or edit the given resource.
200 - InvalidColumnIdException
Ensure the column ID exists and you have access to the resource.
200 - InvalidBoardIdException
Ensure the board ID exists and you have access to the resource.
200 - CreateBoardException
If you’re creating a board from a template, ensure the template ID is a valid monday template or a board that has template status. Learn more about making a board a template here. If you’re duplicating a board, ensure the board ID exists.
200 - ResourceNotFoundException
Ensure the ID of the item, group or board you’re querying exists.
200 - ItemsLimitationException
To prevent abuse, each board has a limit of 10,000 items created via the API. This error is thrown when you have reached the limit.
200 - ItemNameTooLongException
Ensure your item name is between 1 and 255 characters long.
200 - ColumnValueException
If you are updating a column value, ensure the value conforms with each column’s data structure. Learn more here. If you’re retrieving a column value, ensure the column is supported by our API and not calculated in the client (eg, formula column).
If you get an error: "The column has no connected boards" - Ensure the link to item column is connected to a board via the monday.com UI.
200 - CorrectedValueException
If you try to update a column with simple values(string), ensure this column is supporting column values. Learn more about supported columns here.
Querying monday.com entities (object types)
Querying is the way to ask for data, it’s similar to the GET action in REST-based APIs.
In the following sections we’re going to discuss each of the entities you can query and the different data you can extract from each of them. Here is a list of the monday.com entities you can query through the API:
- Boards
- Items
- Items by column values
- Updates
- Tags
- Users
- Teams
Activity Logs
monday.com activity logs are records of all activities performed on a board, use it to know what happened in your board.
ActivityLogType fields
Querying activity logs returns a collection of activity logs in a specific board. Activity logs are available for querying through boards and contain the following fields:
Field |
---|
account_id!String |
created_at!String |
data!String The item's column values in string form. |
entity!String |
event!String |
id!String |
user_id!String |
Board Views
monday.com board views are records of all views added to a board.
BoardView fields
Querying views returns a collection of board views in a specific board. Board views are available for querying through boards and contain the following fields:
Field |
---|
id!ID The view's unique identifier. |
name!String The view's name. |
settings_str!String The view's settings in a string form. |
type!String The view's type. |
Boards
monday.com boards are where our users input all of their data and as such it is one of the core components of the platform and one of the main objects with which you will need to be familiar.
The board’s structure is composed of rows (called items), groups of rows (called groups), and columns. The data of the board is stored in the items of the board and in the updates sections of each item. Each board has one or more owners and subscribers.
Additionally, there are three different board types (main, shareable, private) and each board can have different sets of permissions.
Querying boards
Querying boards returns one board or a collection of boards. Boards can receive the following arguments:
Field | Arguments |
---|---|
boards[Board] Get a collection of boards. | limitInt Number of items to get, the default is 25. pageInt Page number to get, starting at 1. ids[Int] A list of boards unique identifiers. board_kindBoardKind The board's kind (public / private / share) stateState The state of the board (all / active / archived / deleted), the default is active. newest_firstBoolean Get the recently created boards at the top of the list, (Deprecated, use order_by:created_at) order_byBoardsOrderBy Property to order by (created_at / used_at). |
Board fields
As mentioned above, boards are comprised of different components and when querying a board you can request specific fields to be returned. Each board contains the following fields:
Field | Arguments |
---|---|
activity_logs[ActivityLogType] The board log events. | limitInt Number of items to get, the default is 25. pageInt Page number to get, starting at 1. user_ids[Int] User ids to filter. column_ids[String] Column ids to filter group_ids[String] Group ids to filter item_ids[Int] Item id to filter fromISO8601DateTime From timestamp (ISO8601) toISO8601DateTime To timestamp (ISO8601) |
board_folder_idInt The board's folder unique identifier. | |
board_kind!BoardKind The board's kind (public / private / share). | |
columns[Column] The board's visible columns. | ids[String] A list of column unique identifiers. |
communicationJSON Get the board communication value - typically meeting ID | |
descriptionString The board's description. | |
groups[Group] The board's visible groups. | ids[String] A list of group unique identifiers. |
id!ID The unique identifier of the board. | |
items[Item] The board's items (rows). | ids[Int] A list of items unique identifiers. limitInt Number of items to get pageInt Page number to get, starting at 1. newest_firstBoolean Get the recently created items at the top of the list |
name!String The board's name. | |
owner!User The owner of the board. | |
permissions!String The board's permissions. | |
posString The board's position. | |
state!State The board's state (all / active / archived / deleted). | |
subscribers![User] The board's subscribers. | |
tags[Tag] The board's specific tags. | |
top_group!Group The top group at this board. | |
updated_atISO8601DateTime The last time the board was updated at. | |
updates[Update] The board's updates. | limitInt Number of items to get, the default is 25. pageInt Page number to get, starting at 1. |
views[BoardView] The board's views. | ids[Int] A list of view unique identifiers. typeString The view's type |
workspaceWorkspace The workspace that contains this board (null for main workspace). | |
workspace_idInt The board's workspace unique identifier (null for main workspace). |
Column Values
Every monday.com board has one or more columns, each of which holds a particular piece of information. These column values are essentially the content of the board. Their inner value structure varies by type, details can be found here.
ColumnValue fields
Column values are available for querying through items. Each column value contains the following fields:
Field |
---|
additional_infoJSON The column value's additional information. |
id!ID The column's unique identifier. |
textString The column's textual value in string form. |
title!String The column's title. |
type!String The column's type. |
valueJSON The column's value in json format. |
Columns
Columns and items are two core elements of a board. A board is formatted as a table where there are columns and rows called items. In monday.com each column has a specific functionality it enables (ex. a numbers column, a text column, a time tracking column, etc.)
Column fields
Querying columns returns one or a collection of columns. Columns are available for querying through boards and contain the following fields:
Field |
---|
archived!Boolean Is the column archived or not. |
id!ID The column's unique identifier. |
posString The column's position in the board. |
settings_str!String The column's settings in a string form. |
title!String The column's title. |
type!String The column's type. |
widthInt The column's width. |
Complexity
As mentioned in the rate limits section, the amount of API calls each account can perform is limited by complexity per minute. Querying for complexity allows you to determine the complexity of your query and how much of your 1 minute cap will be used.
Querying complexity
Simply add the complexity query to your query and you’ll receive another field which represents the complexity level.
Field |
---|
complexityComplexity Get the complexity data of your queries. |
Complexity fields
Complexity contains the following fields:
Field |
---|
after!Int The remainder of complexity after the query's execution. |
before!Int The remainder of complexity before the query's execution. |
query!Int The specific query's complexity. |
reset_in_x_seconds!Int How long in seconds before the complexity budget is reset |
Files
Any file you upload in monday is saved as an asset. You can query for assets by id or get them through the updates and items queries.
Querying files
Querying files returns one or a collection of assets. Assets can receive the following arguments:
Field | Arguments |
---|---|
assets[Asset] Get a collection of assets by ids. | ids![Int] Ids of the assets/files you want to get |
Asset fields
Files are saved as assets in monday.com. Each asset contains the following fields:
Field |
---|
created_atDate The file's creation date. |
file_extension!String The file's extension. |
file_size!Int The file's size in bytes. |
id!ID The file's unique identifier. |
name!String The file's name. |
public_url!String public url to the asset, valid for 1 hour. |
uploaded_by!User The user who uploaded the file. |
url!String url to view the asset. |
url_thumbnailString url to view the asset in thumbnail mode. Only available for images. |
Groups
Items are grouped together in units called groups. Each board contains one or multiple groups, and each group can hold one or many items.
Group fields
Querying groups returns one group or a collection of groups in a specific board. Groups are available for querying through boards and contain the following fields:
Field | Arguments |
---|---|
archivedBoolean Is the group archived or not. | |
color!String The group's color. | |
deletedBoolean Is the group deleted or not. | |
id!ID The group's unique identifier. | |
items[Item] The items in the group. | ids[Int] A list of items unique identifiers. limitInt Number of items to get pageInt Page number to get, starting at 1. newest_firstBoolean Get the recently created items at the top of the list |
position!String The group's position in the board. | |
title!String The group's title. |
Items
monday.com items are another core object in the platform. Items are the objects that hold the actual data within the board, to better illustrate this, you can think of a board as a table and a item as a single row in that table.
Querying items
Querying items returns one or a collection of items. Items can receive the following arguments:
Field | Arguments |
---|---|
items[Item] Get a collection of items. | limitInt Number of items to get, the default is 25. pageInt Page number to get, starting at 1. ids[Int] A list of items unique identifiers. newest_firstBoolean Get the recently created items at the top of the list |
Item fields
As mentioned above, items hold the actual data within the board. Each item contains columns in which the different values are stored. Each item contains the following fields:
Field | Arguments |
---|---|
assets[Asset] The item's assets/files. | column_ids[String] Ids of the columns you want to get assets from. |
boardBoard The board that contains this item. | |
column_values[ColumnValue] The item's column values. | ids[String] A list of column ids to return |
created_atDate The item's create date. | |
creatorUser The item's creator. | |
creator_id!String The unique identifier of the item creator. | |
groupGroup The group that contains this item. | |
id!ID The item's unique identifier. | |
name!String The item's name. | |
stateState The item's state (all / active / archived / deleted). | |
subscribers![User] The pulses's subscribers. | |
updated_atDate The item's last update date. | |
updates[Update] The item's updates. | limitInt Number of items to get, the default is 25. pageInt Page number to get, starting at 1. |
Items By Column Values
monday.com items are another core object in the platform. Items are the objects that hold the actual data within the board, to better illustrate this, you can think of a board as a table and a item as a single row in that table.
Just like in a table, the different values of each item are stored in columns.
Querying items by column values
Querying items by column values searches for items based on their column values and returns data about those specific items.
Unlike other queries, when querying items by column values there are some arguments that must be included, and some arguments that are optional:
Field | Arguments |
---|---|
items_by_column_values[Item] Search items by their column values. | limitInt Number of items to get pageInt Page number to get, starting at 1. board_id!Int The board's unique identifier. column_id!String The column's unique identifier. column_value!String The column value to search items by. column_typeString The column type. stateState The state of the item (all / active / archived / deleted), the default is active. |
Item fields
As mentioned above, items hold the actual data within the board, while the different values of each item are stored in columns. Each item contains the following fields:
The fields available in items by column values are exactly the same as the fields available in “Items”. You can see them here.
Field | Arguments |
---|---|
assets[Asset] The item's assets/files. | column_ids[String] Ids of the columns you want to get assets from. |
boardBoard The board that contains this item. | |
column_values[ColumnValue] The item's column values. | ids[String] A list of column ids to return |
created_atDate The item's create date. | |
creatorUser The item's creator. | |
creator_id!String The unique identifier of the item creator. | |
groupGroup The group that contains this item. | |
id!ID The item's unique identifier. | |
name!String The item's name. | |
stateState The item's state (all / active / archived / deleted). | |
subscribers![User] The pulses's subscribers. | |
updated_atDate The item's last update date. | |
updates[Update] The item's updates. | limitInt Number of items to get, the default is 25. pageInt Page number to get, starting at 1. |
Me
There is also an option to query the user details of the user whose API key is being used if the API is the personal API key. This is the fastest way to query for the user details (same as users query) of the connected user.
Querying me
The “me field” has the same fields as the Users field.
Field |
---|
meUser Get the connected user's information. |
Tags
monday.com tags are objects that help you group items from different groups or different boards throughout your account by a consistent keyword. Tag entities are created and presented through the “Tags” column.
Querying tags
Querying tags returns one or a collection of the account's public tags. Public tags are the tags that appear in public boards. If you want to find tags of private boards you can use the boards query. Tags can receive only one argument:
Field | Arguments |
---|---|
tags[Tag] Get a collection of tags. | ids[Int] A list of tags unique identifiers. |
Tag fields
Each tag contains the following fields:
Field |
---|
color!String The tag's color. |
id!Int The tag's unique identifier. |
name!String The tag's name. |
Teams
Teams are the most efficient way to manage groups of users in monday.com. Teams are comprised of one or multiple users, and every user can be a part of multiple teams (or none).
Querying teams
Querying teams returns one or several of teams. Users can receive the following arguments:
Field | Arguments |
---|---|
teams[Team] Get a collection of teams. | ids[Int] A list of teams unique identifiers. |
Team fields
Each team contains the following fields:
Field | Arguments |
---|---|
id!Int The team's unique identifier. | |
name!String The team's name. | |
picture_urlString The team's picture url. | |
users[User] The users in the team. | ids[Int] A list of users unique identifiers. kindUserKind The kind to search users by (all / non_guests / guests / non_pending). newest_firstBoolean Get the recently created users at the top of the list limitInt Number of users to get |
Updates
monday.com updates are additional notes and information added to items outside of the structure of the board. The main form of communication within the platform takes place in the updates section.
Querying updates
Querying updates returns one or a collection of updates. Updates can receive the following arguments:
Field | Arguments |
---|---|
updates[Update] Get a collection of updates. | limitInt Number of items to get, the default is 25. pageInt Page number to get, starting at 1. |
Update fields
As mentioned above, updates are additional information within the items. Each update contains the following fields:
Field |
---|
assets[Asset] The update's assets/files. |
body!String The update's html formatted body. |
created_atDate The update's creation date. |
creatorUser The update's creator. |
creator_idString The unique identifier of the update creator. |
id!ID The update's unique identifier. |
item_idString The update's item ID. |
replies[Reply] The update's replies. |
text_bodyString The update's text body. |
updated_atDate The update's last edit date. |
Users
Every user in monday.com is a part of an account (i.e an organization) and could be a member or a guest in that account.
Querying users
Querying users returns one or multiple users. Users can receive the following arguments:
Field | Arguments |
---|---|
users[User] Get a collection of users. | ids[Int] A list of users unique identifiers. kindUserKind The kind to search users by (all / non_guests / guests / non_pending). newest_firstBoolean Get the recently created users at the top of the list limitInt Number of users to get |
User fields
Each user contains the following fields:
Field | Arguments |
---|---|
account!Account The user's account. | |
birthdayDate The user's birthday. | |
country_codeString The user's country code. | |
created_atDate The user's creation date. | |
email!String The user's email. | |
enabled!Boolean Is the user enabled or not. | |
id!Int The user's unique identifier. | |
is_adminBoolean Is the user an account admin. | |
is_guestBoolean Is the user a guest or not. | |
is_pendingBoolean Is the user a pending user | |
is_view_onlyBoolean Is the user a view only user or not. | |
join_dateDate The date the user joined the account. | |
locationString The user's location. | |
mobile_phoneString The user's mobile phone number. | |
name!String The user's name. | |
phoneString The user's phone number. | |
photo_originalString The user's photo in the original size. | |
photo_smallString The user's photo in small size (150x150). | |
photo_thumbString The user's photo in thumbnail size (100x100). | |
photo_thumb_smallString The user's photo in small thumbnail size (50x50). | |
photo_tinyString The user's photo in tiny size (30x30). | |
teams[Team] The teams the user is a member in. | ids[Int] A list of teams unique identifiers. |
time_zone_identifierString The user's timezone identifier. | |
titleString The user's title. | |
url!String The user's profile url. | |
utc_hours_diffInt The user’s utc hours difference. |
Mutating monday.com entities (object types)
In GraphQL Mutations are used to create, modify and delete data (unlike queries that only read data). Mutations also allow you to retrieve specify the fields of the newly created/modified entity as part of the same request.
There are different types of monday.com entities that can be mutated through the API. In the following sections we’re going to dive into each of them, the different data you can mutate, and additional details about how to do so.
Here is a list of the monday.com entities that can be mutated:
- Boards
- Columns
- Groups
- Items
- Updates
- Notifications
- Statuses
- Tags
Boards
monday.com boards are where our users input all of their data and as such it is one of the core components of the platform and one of the main objects with which you will need to be familiar.
The board’s structure is composed of rows (called items), groups of rows (called groups), and columns. The data of the board is stored in the items of the board and in the updates sections of each item. Each board has one or more owners and subscribers.
Additionally, there are three different board types (main, shareable, private) and each board can have different sets of permissions.
Create board
Allows you to create a new board. After the mutation runs you can query back all the board data as shown in the Querying boards section.
To see all the available template ID's go to monday.labs and activate the "Developer mode" feature. You will then be able to see the template ID's in the create board from template screen.
Field | Arguments |
---|---|
create_boardBoard Create a new board. | board_name!String The board's name board_kind!BoardKind The board's kind (public / private / share) folder_idInt Optional board folder id workspace_idInt Optional workspace id template_idInt Optional board template id |
Archive board
Below are the list of options to mutate a board. After the mutation runs you can query back all the board data as shown in the Querying boards section.
Field | Arguments |
---|---|
archive_boardBoard Archive a board. | board_id!Int The board's unique identifier |
Add subscribers to a board
Allows you to add subscribers to a board. You can define if users will be added as regular subscribers or as owners of the board.
Field | Arguments |
---|---|
add_subscribers_to_board[User] Add subscribers to a board. | board_id!Int The board's unique identifier. user_ids![Int] User ids to subscribe to a board kindSubscriberKind Subscribers kind (subscriber / owner) |
Delete subscribers from a board
Allows you to delete subscribers from a board.
Field | Arguments |
---|---|
delete_subscribers_from_board[User] Remove subscribers from the board. | board_id!Int The board's unique identifier. user_ids![Int] User ids to subscribe to a board |
Duplicate a board
The duplicate board mutation duplicates a board with all of its items and groups, to a specific workspace/folder of your choice. The query will return data of the board created as well as whether the process is synchronous or asynchronous. Please note that an asynchronous duplication process may take some time to complete, therefore the initial returned data might be partial.
Field | Arguments |
---|---|
duplicate_boardBoardDuplication Duplicate a board. | board_id!Int The board's unique identifier. duplicate_type!DuplicateBoardType The duplication type. board_nameString Optional the new board's name. If omitted then automaticlly generated workspace_idInt Optional destination workspace. Defaults to the original board workspace. folder_idInt Optional destination folder in destionation workspace. Defaults to the original board folder. keep_subscribersBoolean Duplicate the subscribers to the new board. Defaults to false. |
Columns
Columns and items are two core elements of a board. A board is formatted as a table where there are columns and rows called items. In monday.com each column has a specific functionality it enables (ex. a numbers column, a text column, a time tracking column, etc.)
Create column
Allows to add a new column to the different board through the API. After the mutation runs you can query back the column data as shown in the Querying columns section.
Field | Arguments |
---|---|
create_columnColumn Create a new column in board. | board_id!Int The board's unique identifier. title!String The new column's title. column_typeColumnType The type of column to create. defaultsJSON The new column's defaults. |
Change simple column value
The data of each item is stored in columns. The change simple column value mutation allows you to change the value of a column in a specific item (row), with a string.
Each column has a certain type, and different column types expect a different set of parameters to update their values.
When sending data to a particular column, use a string. To check how to send the data for each column please see changing simple column values section
You can also use the simple values in create_item, create_sub_item and change_multiple_column_values mutations.
You can combine simple and regular values in your mutation. This is useful when you want to update columns that do not support simple column values. .
After the mutation runs you can query the board data, as shown in the Querying columns section.
Field | Arguments |
---|---|
change_simple_column_valueItem Change an item's column with simple value. | item_idInt The item's unique identifier. column_id!String The column's unique identifier. board_id!Int The board's unique identifier. value!String The new simple value of the column. |
Change column value
The data of each item is stored in columns. The change column value mutation allows you to change the value of a column in a specific item (row).
Each column has a certain type, and different column types expect a different set of parameters to update their values. When sending data to a particular column, use a JSON-formatted string (if you’re using Javascript, you can use JSON.stringify() to convert a JSON object into a string). To check how to send the data for each column please see changing column values section.
After the mutation runs you can query back the column data as shown in the Querying columns section.
Field | Arguments |
---|---|
change_column_valueItem Change an item's column value. | item_idInt The item's unique identifier. column_id!String The column's unique identifier. board_id!Int The board's unique identifier. value!JSON The new value of the column. |
Change multiple column values
This mutation allows you to update multiple columns values of a specific Item (row).
Each column has a certain type, and different column types expect a different set of parameters to update their values. When sending data in the column_values argument, use a string.
The column_values argument is built in the following form (example with text and status columns):
Code example
{\"text\": \"New text\", \"status\": {\"label\": \"Done\"}}
NOTE: You can use also simple values in this mutation, combined with regular values, or just simple values. Example (where status is set with simple value) :
Code example
{\"text\": \"New text\", \"status\": \"Done\"}Example: To check how to send the data for each column please see changing column values section and changing simple column values section.
After the mutation runs you can query back all the columns data as shown in the Querying columns section.
Field | Arguments |
---|---|
change_multiple_column_valuesItem Changes the column values of a specific item. | item_idInt The item's unique identifier. board_id!Int The board's unique identifier. column_values!JSON The column values updates. |
Change column title
This mutation allows you to update the title of an existing column.
After the mutation runs you can query back all the columns data as shown in the Querying columns section.
Field | Arguments |
---|---|
change_column_titleColumn Change a column's title | column_id!String The column's unique identifier. board_id!Int The board's unique identifier. title!String The new title of the column. |
Groups
Items are grouped together in units called groups. Each board contains one or multiple groups, and each group can hold one or many items.
Duplicate group
The duplicate group mutation duplicates a group with all of its items. After the mutation runs you can query back all the group data as shown in the Querying groups section.
Field | Arguments |
---|---|
duplicate_groupGroup Duplicate a group. | board_id!Int The board's unique identifier. group_id!String The group's unique identifier. add_to_topBoolean Should the new group be added to the top. group_titleString The group's title. |
Create group
The create group mutation creates a new empty group. After the mutation runs you can query back all the group data as shown in the Querying groups section.
Field | Arguments |
---|---|
create_groupGroup Creates a new group in a specific board. | board_id!Int The board's unique identifier. group_name!String The name of the new group. |
Archive group
The archive group mutation archives a group with all of its items. After the mutation runs you can query back all the group data as shown in the Querying groups section.
Field | Arguments |
---|---|
archive_groupGroup Archives a group in a specific board. | board_id!Int The board's unique identifier. group_id!String The group's unique identifier. |
Delete group
The delete group mutation deletes a group with all of its items. After the mutation runs you can query back all the group data as shown in the Querying groups section.
Field | Arguments |
---|---|
delete_groupGroup Deletes a group in a specific board. | board_id!Int The board's unique identifier. group_id!String The group's unique identifier. |
Items
monday.com items are another core object in the platform. Items are the objects that hold the actual data within the board, to better illustrate this, you can think of a board as a table and a item as a single row in that table.
Create item
You can create a new item in the different boards through the API with the create item mutation.
The data of each item is stored in the board’s columns, each of which holds a particular piece of information. Each column has a certain type, and different column types expect a different set of parameters to update their values. When sending data to a particular column, use a JSON-formatted string (if you’re using Javascript, you can use JSON.stringify() to convert a JSON object into a string).
NOTE: You can use also simple values in this mutation, combined with regular values, or just simple values.
To check how to send the data for each column please see changing column values section and changing simple column values section.
After the mutation runs you can query back the item data as shown in the Querying items section.
Field | Arguments |
---|---|
create_itemItem Create a new item. | item_nameString The new item's name. board_id!Int The board's unique identifier. group_idString The group's unique identifier. column_valuesJSON The column values of the new item. |
Create subitem
You can create a new subitem for any parent item through the API with the create subitem mutation.
Subitems are technically created under a different board, which is NOT the same board as parent item's board. You can query the identifier of this board through the regular Board resolver of the subitem. Using this board ID and subitem ID you can apply any actions to the subitem as to a regular item, f.e. archive it, delete, change column_values, etc.
NOTE: For creating subitems via the API, the board should already have subitems column or at least one subitem created, otherwise you will receive an error.
After the mutation runs you can query back all the subitem data the same as for a regular item as shown in the Querying items section.
Field | Arguments |
---|---|
create_subitemItem Create subitem. | parent_item_idInt The parent item's unique identifier. item_nameString The new item's name. column_valuesJSON The column values of the new item. |
Clear item's updates
This mutation allows one to clear all updates on a specific item, including replies and likes. After the mutation runs you can query back the item data as shown in the Querying items section.
Field | Arguments |
---|---|
clear_item_updatesItem Clear an item's updates. | item_id!Int The item's unique identifier. |
Move item to group
This mutation allows one to move a item between groups in the same board. After the mutation runs you can query back the item data as shown in the Querying items section.
Field | Arguments |
---|---|
move_item_to_groupItem Move an item to a different group. | item_idInt The item's unique identifier. group_id!String The group's unique identifier. |
Archive item
This mutation allows one to archive a single item. After the mutation runs you can query back the item data as shown in the Querying items section.
Field | Arguments |
---|---|
archive_itemItem Archive an item. | item_idInt The item's unique identifier. |
Delete item
This mutation allows one to delete a single item. After the mutation runs you can query back the remaining items data as shown in the Querying items section.
Field | Arguments |
---|---|
delete_itemItem Delete an item. | item_idInt The item's unique identifier. |
Duplicate item
This mutation allows one to duplicate a single item. After the mutation runs you can query back the item data as shown in the Querying items section.
Field | Arguments |
---|---|
duplicate_itemItem Duplicate an item. | board_id!Int The board's unique identifier. with_updatesBoolean Duplicate with the item's updates. item_idInt The item's unique identifier. *Required |
Updates
monday.com updates are additional notes and information added to items outside of the structure of the board. The main form of communication within the platform takes place in the Querying updates section.
Create update
The create update mutation allows one to add an update to a item. After the mutation runs you can query back the update data as shown in the Querying updates section.
Field | Arguments |
---|---|
create_updateUpdate Create a new update. | body!String The update text. item_idInt The item's unique identifier. parent_idInt The parent post identifier. |
Delete update
The delete update mutation allows one to delete an update of an item. After the mutation runs you can query back the remaining updates data as shown in the Querying updates section.
Field | Arguments |
---|---|
delete_updateUpdate Delete an update. | id!Int The update's unique identifier. |
Notifications
Notifications are sent in the platform in response to various triggers such as due dates, updates, and more. By default, each notification within the platform will also be sent out as an email to the recipient (this can be customized in the user’s profile settings).
Create notification
Notifications are sent in the platform in response to various triggers such as due dates, updates, and more. By default, each notification within the platform will also be sent out as an email to the recipient (this can be customized in the user’s profile settings).
The create notification mutation allows to trigger a notification within the platform (will also send out an email if the recipient's email preferences allow). Keep in mind that notifications are async and you will not be able to query their ID's back after sending then out.
Field | Arguments |
---|---|
create_notificationNotification Create a new notification. | text!String The notification text. user_id!Int The user's unique identifier. target_id!Int The target's unique identifier. target_type!NotificationTargetType The target's type (Project / Post) kindInt The notification kind. payloadJSON The notification payload. |
Tags
monday.com tags are objects that help you group items from different groups or different boards throughout your account by a consistent keyword.
Create or get tag
The tags mutation allows you to create new tags or receive their data if they already exist. Private boards require separate tags so if you wish to use your tags in a private board use the 'board_id' argument. No need to send this argument for public boards.
Field | Arguments |
---|---|
create_or_get_tagTag Create a new tag or get it if it already exists. | tag_nameString The new tag's name. board_idInt The private board id to create the tag at (not needed for public boards) |
Files
You can upload files to monday.com. Files are saved as "assets" and always belong to a parent object.
NOTE: file requests has different endpoint: api.monday.com/v2/file and are limited to 500MB.
If you are using the monday sdk inside a view app you can use mutations with files included in the variables object, if you are making direct requests to the API you have to use a multipart form request as described in this post
Add a file to an update
Add a file to an existing update. The file will be appended to the bottom of the update.
Field | Arguments |
---|---|
add_file_to_updateAsset Add a file to an update. | update_id!Int The update to add the file to. file!File The file to upload. |
Add a file to a file column value
Add a file to a file column value.
Field | Arguments |
---|---|
add_file_to_columnAsset Add a file to a column value. | item_id!Int The item to add the file to. column_id!String The column to add the file to. file!File The file to upload. |
Webhooks
monday.com webhooks integration allows you to subscribe to events on your boards, and get notified by an HTTP post request to a specified URL with the event information as a payload.
For more information about webhooks, and the webhooks payload Click here.
Create a webhook
The mutation allows you to create a new webhook. After the mutation runs, a webhook subscription will be created based on a specific event. Every time the event happens on your board, the webhook will send data about the event to the subscribed URL.
The URL will have to pass a verification test, where we will send a json POST body request containing a challenge field. We expect you to return the token as a challenge field on your response json body to that request.
The webhooks that you can subscribe to via the API are:
* Some of the events also accept the "config" field. This field is used to pass configuration for the event. Currently, the only event that requires the config field is 'change_specific_column_value'. To use this event, pass a JSON object that contains the column ID you wish to subscribe to.
For example: {"columnId": "status1"}
Field | Arguments |
---|---|
create_webhookWebhook Create a new webhook. | board_id!Int The board's unique identifier. url!String The webhook URL. event!WebhookEventType The event to listen to (incoming_notification / change_column_value / change_specific_column_value / create_item / create_update / change_name / when_date_arrived) configJSON The webhook config |
Delete a webhook
The delete webhook mutation deletes a webhook. After the mutation runs it will no longer report events to the URL given.
Field | Arguments |
---|---|
delete_webhookWebhook Delete a new webhook. | id!Int The webhook's unique identifier. |
Workspaces
Create a workspace
Allows you to create a new workspace. After the mutation runs you can create boards in it as shown in the Creating boards section.
Field | Arguments |
---|---|
create_workspaceWorkspace Create a new workspace. | name!String The Workspace's name kind!WorkspaceKind The workspace's kind (open / closed) descriptionString The Workspace's description |
Changing item column with simple values (strings)
In this section, you will learn how to update column values using strings.
Every monday.com board has one or more columns, each of which holds a particular piece of information. Each column has a certain type, and different column types expect a different set of parameters to update their values. When sending data to a particular column, you can use a simplified format of it using string instead of JSON.
You will mainly need to change item column values in 2 scenarios - when updating the value of an item using the change_column_value mutation, or when creating a new item by using the create_item mutation and setting its values on creation
Code example
Date column
To update a date column, send the date as a string in a YYYY-MM-DD format. You can also add a time by passing a “time” field in HH:MM:SS format.
NOTE: enter the date and time in UTC and it will be converted to the user's timezone when they look at the board.
Ensure you separate the date and hour with a space.
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"2019-06-03 13:25:00"
Dropdown column
Each dropdown column is a collection of ids and their corresponding label. To update a dropdown column, send the ids of the labels you want to set. If you don’t know the ids of the labels you’re trying to set, you can send the labels text instead. You can only use existing labels, and if the labels you sent doesn't exist you will get an error containing all the existing labels and their ids.
You can send a list of ids or labels separated by ','.Note: it is not possible to mix labels with ids in the string.
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"1, 2"
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"dropdown_label_1, dropdown_label_2"
Email column
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"itsmyemail@mailserver.com my email"
Link column
To update a link column, send the URL (including http/https) and display text, separated with a space. You can include spaces in the display text.
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"http://monday.com go to monday!"
Location column
To update a location column send the latitude, longitude and (optionally) the address of the location separated by spaces.
Notes:
- The address is not verified to match the latitude/longitude. It is just used as the text to be displayed in the cell.
- In case no address is provided, the address will be displayed as "unknown".
- The legal values for latitude are between -90.0 and 90.0 exclusive, and for longitude between -180.0 and 180.0 inclusive. If the updated values exceed those ranges, a ColumnValueException will be raised.
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"40.6892494 -74.0445004"
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"29.9772962 31.1324955 Giza Pyramid Complex"
Long text column
To update the long text column, send a string up to 2000 characters.
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"Sample text"
Number column
To update the number column send a string containing a float or int.
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"3"
People column
To update a people column, send a string with the people you want to add to the column, separated by ','. Each number in the string should represent the ID of the person
NOTE: This section refers to both the multiple-person/people column and to person column
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"4616627, 4616435, 4616912"
Phone column
To update a phone column send the phone number (digits only, including the country code) in a string and the iso-2 country code (2 letter code). You can get the list of available countries here.
separate between phone number and country short code with a space.
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"19175998722 US"
Status column
Each status column is a collection of indexes and their corresponding label. To update a status column, send the index of the status you want to set. If you don’t know the index of the label you’re trying to set, you can send the label instead. You can only use existing statuses, and if the label you sent doesn’t exist you will get an error containing all the existing statuses and their indexes.
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"0"
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"Done"
Text column
To update the text column send a string.
Use string value to change value in the GraphiQL editor or in your mutation
Code example
"Sample text"
Changing item column values
Every monday.com board has one or more columns, each of which holds a particular piece of information. Each column has a certain type, and different column types expect a different set of parameters to update their values. When sending data to a particular column, use a JSON-formatted string (if you’re using Javascript, you can use JSON.stringify() to convert a JSON object into a string).
You will mainly need to change item column values in 2 scenarios - when updating the value of an item using the change_column_value mutation, or when creating a new item by using the create_item mutation and setting its values on creation.
Code example
Checkbox column
To check the box in the checkbox column, send a 'checked' field with true. To uncheck the box remove the column value.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "checked": "true" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"checked\":\"true\"}"
Country column
To update a country column send the iso-2 country code (2 letter code) and the country name. You can get the list of available countries here.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "countryCode": "US", "countryName": "United States" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"countryCode\":\"US\",\"countryName\":\"United States\"}"
Date column
To update a date column, send the date as a string in a YYYY-MM-DD format. You can also add a time by passing a “time” field in HH:MM:SS format.
NOTE: enter the date and time in UTC and it will be converted to the user's timezone when they look at the board.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "date": "2019-06-03", "time": "13:25:00" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"date\":\"2019-06-03\",\"time\":\"13:25:00\"}"
Dropdown column
Each dropdown column is a collection of ids and their corresponding label. To update a dropdown column, send the ids of the labels you want to set. If you don’t know the ids of the labels you’re trying to set, you can send the labels text instead. You can only use existing labels, and if the labels you sent doesn’t exist you will get an error containing all the existing labels and their ids.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "ids": [ 1 ] });
JSON string - use this in the GraphiQL editor:
Code example
"{\"ids\":[1]}"
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "labels": [ "My label" ] });
JSON string - use this in the GraphiQL editor:
Code example
"{\"labels\":[\"My label\"]}"
Email column
To update an email column, send the email address in the email field. You can also pass display text in the text field.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "email": "itsmyemail@mailserver.com", "text": "my email" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"email\":\"itsmyemail@mailserver.com\",\"text\":\"my email\"}"
File column
We currently support clearing the File column, details here.
Hour column
To update an hour column, send the hour and minute in 24-hour format.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "hour": 16, "minute": 42 });
JSON string - use this in the GraphiQL editor:
Code example
"{\"hour\":16,\"minute\":42}"
Item name column
To update the item's name, send a string of 1 to 255 characters.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify("My item");
JSON string - use this in the GraphiQL editor:
Code example
"\"My item\""
Link column
To update a link column, write the URL (including http/https) in the url field. You can also pass display text in the text field.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "url": "http://monday.com", "text": "go to monday!" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"url\":\"http://monday.com\",\"text\":\"go to monday!\"}"
Location column
To update a location column send the latitude, longitude and (optionally) the address of the location.
Notes:
- The address is not verified to match the latitude/longitude. It is just used as the text to be displayed in the cell.
- In case no address is provided, the address will be displayed as "unknown".
- The legal values for latitude are between -90.0 and 90.0 exclusive, and for longitude between -180.0 and 180.0 inclusive. If the updated values exceed those ranges, a ColumnValueException will be raised.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "lat": "40.6892494", "lng": "-74.0445004" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"lat\":\"40.6892494\",\"lng\":\"-74.0445004\"}"
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "lat": "29.9772962", "lng": "31.1324955", "address": "Giza Pyramid Complex" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"lat\":\"29.9772962\",\"lng\":\"31.1324955\",\"address\":\"Giza Pyramid Complex\"}"
Long text column
To update the long text column, send a string up to 2000 characters with the key “text”.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "text": "Sample text" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"text\":\"Sample text\"}"
Number column
To update the number column send a string containing a float or int.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify("3");
JSON string - use this in the GraphiQL editor:
Code example
"\"3\""
People column
To update a people column, send an array with the people or teams you want to add to the column. Each item in the array should include an int representing the ID of the person/team, and a string signifying whether the item is a person or a team.
NOTE: This section refers to the multiple-person/people column. If you are trying to update the person column, check out this section.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "personsAndTeams": [ { "id": 4616627, "kind": "person" }, { "id": 4616666, "kind": "person" }, { "id": 51166, "kind": "team" } ] });
JSON string - use this in the GraphiQL editor:
Code example
"{\"personsAndTeams\":[{\"id\":4616627,\"kind\":\"person\"},{\"id\":4616666,\"kind\":\"person\"},{\"id\":51166,\"kind\":\"team\"}]}"
Person column
To update a person column, send an int representing the ID of the user.
NOTE: This section refers to the (deprecated) person column. If you are trying to update the people column, check out this section.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "id": 235326 });
JSON string - use this in the GraphiQL editor:
Code example
"{\"id\":235326}"
Phone column
To update a phone column send the phone number (digits only) in a string and the iso-2 country code (2 letter code). You can get the list of available countries here.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "phone": "11231234567", "countryShortName": "US" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"phone\":\"11231234567\",\"countryShortName\":\"US\"}"
Rating column
To update a rating column send a number between 1 and your rating scale (can be updated in the column settings).
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "rating": 5 });
JSON string - use this in the GraphiQL editor:
Code example
"{\"rating\":5}"
Status column
Each status column is a collection of indexes and their corresponding label. To update a status column, send the index of the status you want to set. If you don’t know the index of the label you’re trying to set, you can send the label instead. You can only use existing statuses, and if the label you sent doesn’t exist you will get an error containing all the existing statuses and their indexes.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "index": 0 });
JSON string - use this in the GraphiQL editor:
Code example
"{\"index\":0}"
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "label": "Done" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"label\":\"Done\"}"
Tags column
To update a tags column, send the tag ID’s in an array.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "tag_ids": [ 295026, 295064 ] });
JSON string - use this in the GraphiQL editor:
Code example
"{\"tag_ids\":[295026,295064]}"
Team column
To update a team column send the ID of the team. The ID of a specific team can be found by using the teams query, checking which teams a particular user is a part of (with the User object), or opening the team’s page in monday.com and copying the number at the end of the URL.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "team_id": 51166 });
JSON string - use this in the GraphiQL editor:
Code example
"{\"team_id\":51166}"
Text column
To update the text column send a string.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify("Sample text");
JSON string - use this in the GraphiQL editor:
Code example
"\"Sample text\""
Timeline column
To update a timeline column, send the start and end dates in a YYYY-MM-DD format, where the start date is “from” and the end date is “to”.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "from": "2019-06-03", "to": "2019-06-07" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"from\":\"2019-06-03\",\"to\":\"2019-06-07\"}"
Week column
To update a week column send the start and end dates in a YYYY-MM-DD format. Date must be 7 days apart (inclusive of the first and last date) and start at the beginning of the work week defined in the account.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "week": { "startDate": "2019-06-10", "endDate": "2019-06-16" } });
JSON string - use this in the GraphiQL editor:
Code example
"{\"week\":{\"startDate\":\"2019-06-10\",\"endDate\":\"2019-06-16\"}}"
World clock column
To update a world clock column, send the timezone of the user as a string in continent/city form. You can get the list of available timezones here.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "timezone": "Europe/London" });
JSON string - use this in the GraphiQL editor:
Code example
"{\"timezone\":\"Europe/London\"}"
Item link column
To update an item link column, send linked items ID's as an array. If items will not belong to the linked board/boards, the exception will be raised.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "item_ids": [ 4616627, 4616628, 4616629 ] });
JSON string - use this in the GraphiQL editor:
Code example
"{\"item_ids\":[4616627,4616628,4616629]}"
Auto calculated columns
Some of the columns in monday.com are auto calculated based on other properties. You cannot update the following columns:
- Progress tracking column
- Auto number column
- Item ID column
- Last updated column
- Creation log column
- Formula column
Removing column values
To remove a column value (delete the existing value) send an empty string for text or number columns or an empty object for more complex columns.
Note: To remove the column value of a File column see the following.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({});
JSON string - use this in the GraphiQL editor:
Code example
"{}"
Removing column values - File column
Removing the value of a File column requires explicitly setting the clear_all flag because this action can not be undone.
Raw JSON - use this in your column values variables:
Code example
JSON.stringify({ "clear_all": true });
JSON string - use this in the GraphiQL editor:
Code example
"{\"clear_all\":true}"
Changelog
Here you can see all the changes we made to our API!
09.02.2021
- Change location column values, using simple string or JSON.
07.01.2021
- Board items field Changed the behavior when passing an empty array to the 'ids' argument. Instead of returning all of the items in the board, it will not return any items at all.
03.01.2021
- Create webhook mutation - added another event: 'change_name'
27.12.2020
- Users - added is_admin field
09.11.2020
- Create webhook mutation - added another event: 'change_specific_column_value'
10.10.2020
- Change column title mutation - allows to change title of a column
07.10.2020
- Querying Files - added file_extension, file_size and uploaded_by to the Asset fields
- Change simple column value - added support for change column values and creating items with simple values
- Column values supported - added all simple column values that are supported
06.10.2020
- Label colors for Status column in settings_str - added to the object that is returned in settings_str for Status column an object with mapping labels to their colors. This object has the next structure:
{ "labels_colors": { "$LABEL_ID": { "color": "#579bfc", "border": "#4387E8", "var_name": "bright-blue" } } }
04.10.2020
- Duplicate item mutation - changed response type from stringified JSON to item
16.09.2020
- Duplicate item mutation - allowing to duplicate exiting item
07.09.2020
- Delete update mutation - allowing to delete existing update
25.08.2020
- Create workspace mutation - allowing to add new workspace
15.06.2020
- Create subitem mutation - allowing to add new subitems under the specific parent item
01.06.2020
- Add subscribers to a board - allowing to add subscribers/owners to a board
- Delete subscribers from a board - allowing to remove subscribers/owners from a board
- Item Link column support - allowing to mutate Item Link columns
05.05.2020
- Changed exception handling to be better aligned with the GraphQL specification. The following exceptions will now return status code 200 instead of a 400 error, and the error message will be in the “errors” key of the response: InvalidBoardIdException, InvalidColumnIdException, ColumnValueException, ItemNameTooLongException
16.04.2020
- Activity Logs - show log events on the board
- Board communication field - query board zoom call configuration
- Board Views - get board views
- Column pos field - get the column position in the board
16.03.2020
- Support clearing of file column
12.03.2020
- Added changelog to our API!