npm install @mondaydotcomorg/api

import { ApiClient } from '@mondaydotcomorg/api';

const client = new ApiClient({
  token: '<YOUR_API_TOKEN>',
});

const client = new ApiClient({
  token: '<YOUR_API_TOKEN>',
  apiVersion: '2025-10',
  requestConfig: {
    errorPolicy: 'all',
  },
});

const result = await client.request(`
  query {
    boards(ids: [12345]) {
      id
      name
      columns { id title type }
    }
  }
`);

console.log(result.boards);

const result = await client.request(
  `query ($ids: [ID!]!) {
    boards(ids: $ids) {
      id
      name
      items_page(limit: 5) {
        items { id name }
      }
    }
  }`,
  { ids: ["12345", "67890"] }
);

import { Board } from '@mondaydotcomorg/api';

const { boards } = await client.request<{ boards: Board[] }>(
  `query { boards(ids: [12345]) { id name } }`
);

const result = await client.request(
  `query { me { id name } }`,
  undefined,
  { versionOverride: '2025-10', timeoutMs: 10000 }
);

const response = await client.rawRequest(`query { me { id name } }`);

console.log(response.data);       // { me: { id: '...', name: '...' } }
console.log(response.extensions);  // API metadata (complexity, etc.)
console.log(response.errors);      // Any GraphQL errors (if errorPolicy allows)

const { me } = await client.operations.getMeOp();
console.log(me.name, me.email);

const { boards } = await client.operations.getBoardItemsOp({
  ids: ["12345"],
});

for (const board of boards) {
  for (const item of board.items_page.items) {
    console.log(item.id, item.name);
    for (const col of item.column_values) {
      console.log(`  ${col.id} (${col.type}): ${col.value}`);
    }
  }
}

const { create_item } = await client.operations.createItemOp({
  boardId: "12345",
  groupId: "topics",
  itemName: "New task from SDK",
});

console.log("Created item:", create_item.id);

// Simple string value (for text columns)
await client.operations.changeSimpleColumnValueOp({
  boardId: "12345",
  itemId: "67890",
  columnId: "text_column",
  value: "Hello from SDK!",
});

// JSON value (for structured columns like status, date, etc.)
await client.operations.changeColumnValueOp({
  boardId: "12345",
  itemId: "67890",
  columnId: "status_column",
  value: JSON.stringify({ label: "Done" }),
});

await client.operations.changeMultipleColumnValuesOp({
  boardId: "12345",
  itemId: "67890",
  columnValues: JSON.stringify({
    text_column: "Updated text",
    status_column: { label: "Working on it" },
    date_column: { date: "2026-04-01" },
  }),
});

import { ApiClient } from '@mondaydotcomorg/api';
import { readFileSync } from 'fs';

const client = new ApiClient({ token: '<YOUR_API_TOKEN>' });

const file = new File(
  [readFileSync('./report.pdf')],
  'report.pdf',
  { type: 'application/pdf' }
);

const result = await client.request(
  `mutation ($file: File!, $itemId: ID!, $columnId: String!) {
    add_file_to_column(file: $file, item_id: $itemId, column_id: $columnId) {
      id
      name
      url
    }
  }`,
  {
    file,
    itemId: '67890',
    columnId: 'files',
  }
);

console.log(result.add_file_to_column);

import { ApiClient, ClientError } from '@mondaydotcomorg/api';

const client = new ApiClient({ token: '<YOUR_API_TOKEN>' });

try {
  await client.request(`query { invalid_field }`);
} catch (error) {
  if (error instanceof ClientError) {
    console.error('GraphQL errors:', error.response.errors);
    // [{ message: 'Cannot query field "invalid_field" on type "Query".', locations: [...] }]
  } else {
    console.error('Network or other error:', error);
  }
}

const client = new ApiClient({
  token: '<YOUR_API_TOKEN>',
  requestConfig: { errorPolicy: 'all' },
});

const response = await client.rawRequest(`query { ... }`);
console.log(response.data);    // partial data (if any)
console.log(response.errors);  // error details

import { SeamlessApiClient, Board } from '@mondaydotcomorg/api';

const client = new SeamlessApiClient();

const { boards } = await client.request<{ boards: Board[] }>(
  `query { boards(ids: [12345]) { id name } }`
);

import { SeamlessApiClient, SeamlessApiClientError } from '@mondaydotcomorg/api';

const client = new SeamlessApiClient();

try {
  await client.request(`query { boards { id } }`);
} catch (error) {
  if (error instanceof SeamlessApiClientError) {
    console.error(error.message);
    console.error(error.response.errors);
  }
}

// Set at client creation (applies to all requests including operations)
const client = new ApiClient({
  token: '<YOUR_API_TOKEN>',
  apiVersion: '2025-10',
});

// Override per-request
const result = await client.request(
  `query { me { id } }`,
  undefined,
  { versionOverride: '2026-01' }
);

import { DEFAULT_VERSION, MONDAY_API_ENDPOINT, AvailableVersions } from '@mondaydotcomorg/api';

console.log(DEFAULT_VERSION);        // '2026-01'
console.log(MONDAY_API_ENDPOINT);    // 'https://api.monday.com/v2'
console.log(AvailableVersions);      // { CURRENT_VERSION: '2026-01', CURRENT: 'current', ... }

import { Board, Item, ColumnType, BoardKind } from '@mondaydotcomorg/api';

const processItem = (item: Item) => {
  for (const col of item.column_values) {
    if (col.type === ColumnType.Status) {
      console.log(`Status column ${col.id}:`, col.value);
    }
  }
};

npx @mondaydotcomorg/setup-api

import gql from 'graphql-tag';

export const getBoards = gql`
  query GetBoards($ids: [ID!]) {
    boards(ids: $ids) {
      id
      name
      columns { id title type }
      groups { id title }
    }
  }
`;

export const createItem = gql`
  mutation CreateItem($boardId: ID!, $groupId: String!, $itemName: String!) {
    create_item(board_id: $boardId, group_id: $groupId, item_name: $itemName) {
      id
      name
    }
  }
`;

npm run fetch:generate

import { ApiClient } from '@mondaydotcomorg/api';
import { GetBoardsQuery, GetBoardsQueryVariables } from './generated/graphql';
import { getBoards } from './queries.graphql';

const client = new ApiClient({ token: '<YOUR_API_TOKEN>' });

const variables: GetBoardsQueryVariables = { ids: ["12345"] };
const data = await client.request<GetBoardsQuery>(getBoards, variables);

// data.boards is fully typed based on your query's selected fields

npm run codegen

npm run fetch:generate

import { ApiClient, Board, ColumnType } from '@mondaydotcomorg/api';

const client = new ApiClient({ token: '<YOUR_API_TOKEN>' });

// Get board structure
const { boards } = await client.request<{ boards: Board[] }>(`
  query {
    boards(ids: [12345]) {
      id
      name
      columns { id title type }
      groups { id title }
    }
  }
`);

// Get items with column values
const { boards: boardsWithItems } = await client.operations.getBoardItemsOp({
  ids: ["12345"],
});

for (const item of boardsWithItems[0].items_page.items) {
  console.log(`Item: ${item.name}`);
  for (const col of item.column_values) {
    console.log(`  ${col.id}: ${col.value}`);
  }
}

import { ApiClient } from '@mondaydotcomorg/api';

const client = new ApiClient({ token: '<YOUR_API_TOKEN>' });

// Create an item
const { create_item } = await client.operations.createItemOp({
  boardId: "12345",
  groupId: "topics",
  itemName: "New feature request",
});

// Update multiple columns on the new item
await client.operations.changeMultipleColumnValuesOp({
  boardId: "12345",
  itemId: create_item.id,
  columnValues: JSON.stringify({
    status: { label: "Working on it" },
    text: "Description of the feature",
    date: { date: "2026-04-15" },
    person: { personsAndTeams: [{ id: 12345678, kind: "person" }] },
  }),
});

import { ApiClient, ClientError } from '@mondaydotcomorg/api';
import { GetBoardsQuery, GetBoardsQueryVariables, CreateItemMutation, CreateItemMutationVariables } from './generated/graphql';
import { getBoards, createItem } from './queries.graphql';

const client = new ApiClient({ token: '<YOUR_API_TOKEN>' });

// Typed query
const queryVars: GetBoardsQueryVariables = { ids: ["12345"] };
const boardData = await client.request<GetBoardsQuery>(getBoards, queryVars);

// Typed mutation
const mutationVars: CreateItemMutationVariables = {
  boardId: "12345",
  groupId: "topics",
  itemName: "Created with typed SDK!",
};
const itemData = await client.request<CreateItemMutation>(createItem, mutationVars);

import { ApiClient, ClientError } from '@mondaydotcomorg/api';

const client = new ApiClient({ token: '<YOUR_API_TOKEN>' });

async function safeRequest<T>(query: string, variables?: Record<string, any>): Promise<T | null> {
  try {
    return await client.request<T>(query, variables);
  } catch (error) {
    if (error instanceof ClientError) {
      const gqlErrors = error.response.errors;
      for (const err of gqlErrors) {
        if (err.message.includes('complexity')) {
          console.error('Complexity budget exceeded. Simplify your query.');
        } else if (err.message.includes('Rate limit')) {
          console.error('Rate limited. Implement backoff.');
        } else {
          console.error('GraphQL error:', err.message);
        }
      }
    } else {
      console.error('Unexpected error:', error);
    }
    return null;
  }
}

import { ApiClient } from '@mondaydotcomorg/api';
import { readFileSync } from 'fs';

const client = new ApiClient({ token: '<YOUR_API_TOKEN>' });

const fileBuffer = readFileSync('./document.pdf');
const file = new File([fileBuffer], 'document.pdf', { type: 'application/pdf' });

const result = await client.request(
  `mutation ($file: File!, $itemId: ID!, $columnId: String!) {
    add_file_to_column(file: $file, item_id: $itemId, column_id: $columnId) {
      id
      name
      url
    }
  }`,
  { file, itemId: "67890", columnId: "files" }
);

// Classes
import { ApiClient, SeamlessApiClient } from '@mondaydotcomorg/api';

// Error types
import { ClientError, SeamlessApiClientError } from '@mondaydotcomorg/api';

// Constants
import { DEFAULT_VERSION, MONDAY_API_ENDPOINT, AvailableVersions } from '@mondaydotcomorg/api';

// Types (examples — hundreds are available)
import { Board, Item, Column, ColumnValue, User, Group, Workspace, Asset, Update, Tag } from '@mondaydotcomorg/api';

// Enums (examples)
import { ColumnType, BoardKind, State, WorkspaceKind, BoardObjectType } from '@mondaydotcomorg/api';