diff --git a/client/src/api/boards.js b/client/src/api/boards.js
index c804b4ded..b1db0ea03 100755
--- a/client/src/api/boards.js
+++ b/client/src/api/boards.js
@@ -7,14 +7,25 @@ import http from './http';
 import socket from './socket';
 import { transformCard } from './cards';
 import { transformAttachment } from './attachments';
+import { getAccessToken } from '../utils/access-token-storage';
+import Config from '../constants/Config';
 
 /* Actions */
 
 const createBoard = (projectId, data, headers) =>
   socket.post(`/projects/${projectId}/boards`, data, headers);
 
-const createBoardWithImport = (projectId, data, requestId, headers) =>
-  http.post(`/projects/${projectId}/boards?requestId=${requestId}`, data, headers);
+const createBoardWithImport = (projectId, data, requestId, headers) => {
+  const { importMapping, ...formDataFields } = data;
+
+  let url = `/projects/${projectId}/boards?requestId=${requestId}`;
+  if (importMapping) {
+    url += `&importMapping=${encodeURIComponent(importMapping)}`;
+  }
+
+  return http.post(url, formDataFields, headers);
+}
+
 
 const getBoard = (id, subscribe, headers) =>
   socket
@@ -32,10 +43,35 @@ const updateBoard = (id, data, headers) => socket.patch(`/boards/${id}`, data, h
 
 const deleteBoard = (id, headers) => socket.delete(`/boards/${id}`, undefined, headers);
 
+const previewFocalboardImport = (file) => {
+  const accessToken = getAccessToken();
+
+  const formData = new FormData();
+  formData.append('file', file);
+
+  return fetch(`${Config.SERVER_BASE_URL}/api/focalboard/preview`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+    body: formData,
+    credentials: 'include',
+  })
+    .then((response) => {
+      if (!response.ok) {
+        return response.json().then((body) => {
+          throw body;
+        });
+      }
+      return response.json();
+    });
+};
+
 export default {
   createBoard,
   createBoardWithImport,
   getBoard,
   updateBoard,
   deleteBoard,
+  previewFocalboardImport,
 };
diff --git a/client/src/api/http.js b/client/src/api/http.js
index 4d5ceca1a..88bd9493d 100755
--- a/client/src/api/http.js
+++ b/client/src/api/http.js
@@ -10,13 +10,13 @@ const http = {};
 // TODO: add all methods
 ['GET', 'POST', 'DELETE'].forEach((method) => {
   http[method.toLowerCase()] = (url, data, headers) => {
-    const formData =
-      data &&
-      Object.keys(data).reduce((result, key) => {
-        result.append(key, data[key]);
 
-        return result;
-      }, new FormData());
+  const formData =
+    data &&
+    Object.keys(data).reduce((result, key) => {
+      result.append(key, data[key]);
+      return result;
+    }, new FormData());
 
     return fetch(`${Config.SERVER_BASE_URL}/api${url}`, {
       method,
diff --git a/client/src/components/boards/AddBoardStep/AddBoardStep.jsx b/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
index de859a9b5..a6e7a4837 100755
--- a/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
+++ b/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
@@ -22,6 +22,11 @@ const StepTypes = {
   IMPORT: 'IMPORT',
 };
 
+const IMPORT_TYPE_ICONS = {
+  trello: 'trello',
+  focalboard: 'file',
+};
+
 const AddBoardStep = React.memo(({ onClose }) => {
   const dispatch = useDispatch();
   const [t] = useTranslation();
@@ -47,6 +52,17 @@ const AddBoardStep = React.memo(({ onClose }) => {
       return;
     }
 
+    // Transform import data for API
+    if (cleanData.import) {
+      const { type, file, mapping } = cleanData.import;
+      cleanData.import = {
+        type,
+        file,
+        // Include mapping for Focalboard imports
+        ...(mapping && { mapping }),
+      };
+    }
+
     dispatch(entryActions.createBoardInCurrentProject(cleanData));
     onClose();
   }, [onClose, dispatch, data, nameFieldRef]);
@@ -56,6 +72,7 @@ const AddBoardStep = React.memo(({ onClose }) => {
       setData((prevData) => ({
         ...prevData,
         import: nextImport,
+        name: nextImport.boardTitle || prevData.name,
       }));
     },
     [setData],
@@ -84,6 +101,8 @@ const AddBoardStep = React.memo(({ onClose }) => {
     return <ImportStep onSelect={handleImportSelect} onBack={handleImportBack} />;
   }
 
+  const importIconName = data.import ? (IMPORT_TYPE_ICONS[data.import.type] || 'file') : 'arrow down';
+
   return (
     <>
       <Popup.Header>
@@ -111,7 +130,7 @@ const AddBoardStep = React.memo(({ onClose }) => {
               onClick={handleImportClick}
             >
               <Icon
-                name={data.import ? data.import.type : 'arrow down'}
+                name={importIconName}
                 className={styles.importButtonIcon}
               />
               {data.import ? data.import.file.name : t('action.import')}
diff --git a/client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx
new file mode 100644
index 000000000..f098a41f3
--- /dev/null
+++ b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx
@@ -0,0 +1,367 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+import React, { useCallback, useEffect, useState, useMemo } from 'react';
+import PropTypes from 'prop-types';
+import { useTranslation } from 'react-i18next';
+import { Button, Checkbox, Dropdown, Form, Loader, Message } from 'semantic-ui-react';
+import { Popup } from '../../../lib/custom-ui';
+
+import api from '../../../api';
+
+import styles from './FocalboardMappingStep.module.scss';
+
+// Property types that can be used for each mapping
+const COLUMN_TYPES = ['select'];
+const LABEL_TYPES = ['select', 'multiSelect'];
+const DUE_DATE_TYPES = ['date'];
+
+// Supported custom field types (stored as strings in Planka)
+const SUPPORTED_CUSTOM_FIELD_TYPES = ['text', 'url', 'number', 'email', 'phone', 'checkbox'];
+
+// All custom field types to show (excluding column/label types)
+const ALL_CUSTOM_FIELD_TYPES = [
+  'text', 'url', 'number', 'email', 'phone', 'checkbox', 'date',
+  'person', 'multiPerson', 'file', 'createdTime', 'createdBy', 'updatedTime', 'updatedBy',
+];
+
+const FocalboardMappingStep = React.memo(({ file, onSelect, onBack }) => {
+  const [t] = useTranslation();
+
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [previewData, setPreviewData] = useState(null);
+
+  // User selections
+  const [useBoardTitle, setUseBoardTitle] = useState(true);
+  const [columnPropertyId, setColumnPropertyId] = useState(null);
+  const [labelPropertyId, setLabelPropertyId] = useState(null);
+  const [dueDatePropertyId, setDueDatePropertyId] = useState(null);
+  const [customFieldPropertyIds, setCustomFieldPropertyIds] = useState([]);
+
+  // Fetch preview data on mount
+  useEffect(() => {
+    let cancelled = false;
+
+    const fetchPreview = async () => {
+      setIsLoading(true);
+      setError(null);
+
+      try {
+        const data = await api.previewFocalboardImport(file);
+
+        if (cancelled) return;
+
+        setPreviewData(data);
+
+        // Auto-select column property from Kanban view
+        const kanbanView = data.views.find((v) => v.type === 'board');
+        if (kanbanView?.groupById) {
+          setColumnPropertyId(kanbanView.groupById);
+        }
+      } catch (err) {
+        if (cancelled) return;
+        setError(err.message || 'Failed to parse file');
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    };
+
+    fetchPreview();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [file]);
+
+  // Filter properties by type for each dropdown
+  const columnOptions = useMemo(() => {
+    if (!previewData) return [];
+    return previewData.properties
+      .filter((p) => COLUMN_TYPES.includes(p.type))
+      .map((p) => ({
+        key: p.id,
+        value: p.id,
+        text: `${p.name} (${p.options?.length || 0} options)`,
+      }));
+  }, [previewData]);
+
+  const labelOptions = useMemo(() => {
+    if (!previewData) return [];
+    return [
+      { key: 'none', value: '', text: t('common.none') },
+      ...previewData.properties
+        .filter((p) => LABEL_TYPES.includes(p.type))
+        .map((p) => ({
+          key: p.id,
+          value: p.id,
+          text: `${p.name} (${p.options?.length || 0} options)`,
+        })),
+    ];
+  }, [previewData, t]);
+
+  const dueDateOptions = useMemo(() => {
+    if (!previewData) return [];
+    return [
+      { key: 'none', value: '', text: t('common.none') },
+      ...previewData.properties
+        .filter((p) => DUE_DATE_TYPES.includes(p.type))
+        .map((p) => ({
+          key: p.id,
+          value: p.id,
+          text: p.name,
+        })),
+    ];
+  }, [previewData, t]);
+
+  // Get all custom field properties (excluding those used for columns/labels)
+  const customFieldProperties = useMemo(() => {
+    if (!previewData) return [];
+    return previewData.properties.filter((p) =>
+      ALL_CUSTOM_FIELD_TYPES.includes(p.type) &&
+      !COLUMN_TYPES.includes(p.type) &&
+      !LABEL_TYPES.includes(p.type)
+    );
+  }, [previewData]);
+
+  // Get only supported custom field IDs (for select all)
+  const supportedCustomFieldIds = useMemo(() => {
+    return customFieldProperties
+      .filter((p) => SUPPORTED_CUSTOM_FIELD_TYPES.includes(p.type))
+      .map((p) => p.id);
+  }, [customFieldProperties]);
+
+  // Check if a property type is supported
+  const isTypeSupported = useCallback((type) => {
+    return SUPPORTED_CUSTOM_FIELD_TYPES.includes(type);
+  }, []);
+
+  // Handlers
+  const handleUseBoardTitleChange = useCallback(() => {
+    setUseBoardTitle((prev) => !prev);
+  }, []);
+
+  const handleColumnChange = useCallback((_, { value }) => {
+    setColumnPropertyId(value);
+  }, []);
+
+  const handleLabelChange = useCallback((_, { value }) => {
+    setLabelPropertyId(value);
+  }, []);
+
+  const handleDueDateChange = useCallback((_, { value }) => {
+    setDueDatePropertyId(value);
+  }, []);
+
+  const handleCustomFieldToggle = useCallback((propertyId, isSupported) => {
+    // Only allow toggling supported types
+    if (!isSupported) return;
+
+    setCustomFieldPropertyIds((prev) =>
+      prev.includes(propertyId)
+        ? prev.filter((id) => id !== propertyId)
+        : [...prev, propertyId]
+    );
+  }, []);
+
+  const handleSelectAllCustomFields = useCallback(() => {
+    setCustomFieldPropertyIds(supportedCustomFieldIds);
+  }, [supportedCustomFieldIds]);
+
+  const handleDeselectAllCustomFields = useCallback(() => {
+    setCustomFieldPropertyIds([]);
+  }, []);
+
+  const handleSubmit = useCallback(() => {
+    if (!columnPropertyId) return;
+
+    // Just call onSelect - ImportStep will handle navigation
+    onSelect({
+      type: 'focalboard',
+      file,
+      boardTitle: useBoardTitle ? previewData.board.title : null,
+      mapping: {
+        columnPropertyId,
+        labelPropertyId: labelPropertyId || undefined,
+        dueDatePropertyId: dueDatePropertyId || undefined,
+        customFieldPropertyIds: customFieldPropertyIds.length > 0 ? customFieldPropertyIds : undefined,
+      },
+    });
+  }, [file, useBoardTitle, previewData, columnPropertyId, labelPropertyId, dueDatePropertyId, customFieldPropertyIds, onSelect]);
+
+  // Loading state
+  if (isLoading) {
+    return (
+      <>
+        <Popup.Header onBack={onBack}>
+          {t('common.focalboardImport', { context: 'title' })}
+        </Popup.Header>
+        <Popup.Content>
+          <div className={styles.loaderWrapper}>
+            <Loader active inline="centered" />
+            <p>{t('common.parsingFile')}</p>
+          </div>
+        </Popup.Content>
+      </>
+    );
+  }
+
+  // Error state
+  if (error) {
+    return (
+      <>
+        <Popup.Header onBack={onBack}>
+          {t('common.focalboardImport', { context: 'title' })}
+        </Popup.Header>
+        <Popup.Content>
+          <Message negative>
+            <Message.Header>{t('common.error')}</Message.Header>
+            <p>{error}</p>
+          </Message>
+        </Popup.Content>
+      </>
+    );
+  }
+
+  return (
+    <>
+      <Popup.Header onBack={onBack}>
+        {t('common.focalboardImport', { context: 'title' })}
+      </Popup.Header>
+      <Popup.Content>
+        <div className={styles.boardInfo}>
+          <div className={styles.boardTitleRow}>
+            <Checkbox
+              checked={useBoardTitle}
+              onChange={handleUseBoardTitleChange}
+            />
+            <strong
+              className={useBoardTitle ? styles.boardTitleActive : styles.boardTitleInactive}
+              onClick={handleUseBoardTitleChange}
+            >
+              {previewData.board.title}
+            </strong>
+          </div>
+          <span className={styles.stats}>
+            {t('common.cardsCount', { count: previewData.stats.totalCards })}
+          </span>
+        </div>
+
+        <Form onSubmit={handleSubmit}>
+          {/* Columns (required) */}
+          <div className={styles.section}>
+            <div className={styles.label}>
+              {t('common.columns')} <span className={styles.required}>*</span>
+            </div>
+            <Dropdown
+              fluid
+              selection
+              options={columnOptions}
+              value={columnPropertyId}
+              placeholder={t('common.selectProperty')}
+              onChange={handleColumnChange}
+            />
+          </div>
+
+          {/* Labels (optional) */}
+          <div className={styles.section}>
+            <div className={styles.label}>{t('common.labels')}</div>
+            <Dropdown
+              fluid
+              selection
+              options={labelOptions}
+              value={labelPropertyId || ''}
+              placeholder={t('common.selectProperty')}
+              onChange={handleLabelChange}
+            />
+          </div>
+
+          {/* Due Date (optional) */}
+          <div className={styles.section}>
+            <div className={styles.label}>{t('common.byDueDate')}</div>
+            <Dropdown
+              fluid
+              selection
+              options={dueDateOptions}
+              value={dueDatePropertyId || ''}
+              placeholder={t('common.selectProperty')}
+              onChange={handleDueDateChange}
+            />
+          </div>
+
+          {/* Custom Fields (optional, multiple) */}
+          {customFieldProperties.length > 0 && (
+            <div className={styles.section}>
+              <div className={styles.labelWithActions}>
+                <span className={styles.label}>{t('common.customFields_title')}</span>
+                <div className={styles.actions}>
+                  <Button
+                    type="button"
+                    className={styles.actionButton}
+                    onClick={handleSelectAllCustomFields}
+                  >
+                    {t('action.selectAll')}
+                  </Button>
+                  <Button
+                    type="button"
+                    className={styles.actionButton}
+                    onClick={handleDeselectAllCustomFields}
+                  >
+                    {t('action.deselectAll')}
+                  </Button>
+                </div>
+              </div>
+              <div className={styles.checkboxList}>
+                {customFieldProperties.map((property) => {
+                  const supported = isTypeSupported(property.type);
+                  return (
+                    <div
+                      key={property.id}
+                      className={`${styles.checkboxItem} ${!supported ? styles.checkboxItemDisabled : ''}`}
+                    >
+                      <Checkbox
+                        checked={customFieldPropertyIds.includes(property.id)}
+                        disabled={!supported}
+                        label={
+                          <label className={styles.checkboxLabel}>
+                            <span className={!supported ? styles.propertyNameDisabled : ''}>
+                              {property.name}
+                            </span>
+                            <span className={`${styles.propertyType} ${!supported ? styles.propertyTypeUnsupported : ''}`}>
+                              {supported ? property.type : t('common.unsupported')}
+                            </span>
+                          </label>
+                        }
+                        onChange={() => handleCustomFieldToggle(property.id, supported)}
+                      />
+                    </div>
+                  );
+                })}
+              </div>
+            </div>
+          )}
+
+          <Button
+            positive
+            fluid
+            content={t('action.import')}
+            disabled={!columnPropertyId}
+            className={styles.submitButton}
+          />
+        </Form>
+      </Popup.Content>
+    </>
+  );
+});
+
+FocalboardMappingStep.propTypes = {
+  file: PropTypes.instanceOf(File).isRequired,
+  onSelect: PropTypes.func.isRequired,
+  onBack: PropTypes.func.isRequired,
+};
+
+export default FocalboardMappingStep;
diff --git a/client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss
new file mode 100644
index 000000000..aee179240
--- /dev/null
+++ b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss
@@ -0,0 +1,155 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+ :global(#app) {
+  .loaderWrapper {
+    padding: 32px 0;
+    text-align: center;
+
+    p {
+      color: #6b808c;
+      margin-top: 16px;
+    }
+  }
+
+  .boardInfo {
+    background: rgba(9, 30, 66, 0.04);
+    border-radius: 3px;
+    margin-bottom: 12px;
+    padding: 10px 12px;
+  }
+
+  .boardTitleRow {
+    align-items: center;
+    display: flex;
+    gap: 8px;
+    margin-bottom: 4px;
+  }
+
+  .boardTitleActive {
+    color: #172b4d;
+    cursor: pointer;
+
+    &:hover {
+      text-decoration: underline;
+    }
+  }
+
+  .boardTitleInactive {
+    color: #6b808c;
+    cursor: pointer;
+    text-decoration: line-through;
+
+    &:hover {
+      color: #172b4d;
+    }
+  }
+
+  .stats {
+    color: #6b808c;
+    font-size: 12px;
+  }
+
+  .section {
+    margin-bottom: 12px;
+  }
+
+  .label {
+    color: #444444;
+    font-size: 12px;
+    font-weight: bold;
+    padding-bottom: 6px;
+  }
+
+  .required {
+    color: #eb5a46;
+  }
+
+  .labelWithActions {
+    align-items: center;
+    display: flex;
+    justify-content: space-between;
+    padding-bottom: 6px;
+
+    .label {
+      padding-bottom: 0;
+    }
+  }
+
+  .actions {
+    display: flex;
+    gap: 4px;
+  }
+
+  .actionButton {
+    background: transparent !important;
+    box-shadow: none !important;
+    color: #6b808c !important;
+    font-size: 11px !important;
+    font-weight: normal !important;
+    padding: 4px 8px !important;
+    text-decoration: underline;
+
+    &:hover {
+      background: rgba(9, 30, 66, 0.08) !important;
+      color: #092d42 !important;
+    }
+  }
+
+  .checkboxList {
+    background: rgba(9, 30, 66, 0.04);
+    border-radius: 3px;
+    max-height: 180px;
+    overflow-y: auto;
+    padding: 4px;
+  }
+
+  .checkboxItem {
+    border-radius: 3px;
+    padding: 6px 8px;
+
+    &:hover {
+      background: rgba(9, 30, 66, 0.08);
+    }
+  }
+
+  .checkboxItemDisabled {
+    opacity: 0.6;
+
+    &:hover {
+      background: transparent;
+    }
+  }
+
+  .checkboxLabel {
+    align-items: center;
+    display: flex !important;
+    justify-content: space-between;
+    width: 100%;
+  }
+
+  .propertyNameDisabled {
+    color: #6b808c;
+  }
+
+  .propertyType {
+    background: rgba(9, 30, 66, 0.08);
+    border-radius: 3px;
+    color: #6b808c;
+    font-size: 10px;
+    margin-left: 8px;
+    padding: 2px 6px;
+    text-transform: uppercase;
+  }
+
+  .propertyTypeUnsupported {
+    background: rgba(235, 90, 70, 0.1);
+    color: #eb5a46;
+  }
+
+  .submitButton {
+    margin-top: 8px;
+  }
+}
diff --git a/client/src/components/boards/AddBoardStep/ImportStep.jsx b/client/src/components/boards/AddBoardStep/ImportStep.jsx
index 896d220e8..238612e88 100644
--- a/client/src/components/boards/AddBoardStep/ImportStep.jsx
+++ b/client/src/components/boards/AddBoardStep/ImportStep.jsx
@@ -3,29 +3,64 @@
  * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
  */
 
-import React, { useCallback } from 'react';
+import React, { useCallback, useState } from 'react';
 import PropTypes from 'prop-types';
 import { useTranslation } from 'react-i18next';
 import { Button } from 'semantic-ui-react';
 import { FilePicker, Popup } from '../../../lib/custom-ui';
 
+import FocalboardMappingStep from './FocalboardMappingStep';
+
 import styles from './ImportStep.module.scss';
 
 const ImportStep = React.memo(({ onSelect, onBack }) => {
   const [t] = useTranslation();
 
-  const handleFileSelect = useCallback(
-    (type, file) => {
+  // For Focalboard: we need an intermediate step to select property mappings
+  const [focalboardFile, setFocalboardFile] = useState(null);
+
+  const handleTrelloFileSelect = useCallback(
+    (file) => {
       onSelect({
-        type,
+        type: 'trello',
         file,
       });
+      onBack();
+    },
+    [onSelect, onBack],
+  );
+
+  const handleFocalboardFileSelect = useCallback((file) => {
+    // Don't go back yet - show mapping step first
+    setFocalboardFile(file);
+  }, []);
 
+  const handleFocalboardMappingSelect = useCallback(
+    (importData) => {
+      // importData includes: type, file, boardTitle, mapping
+      onSelect(importData);
+      // Go all the way back to AddBoardStep
       onBack();
     },
     [onSelect, onBack],
   );
 
+  const handleFocalboardMappingBack = useCallback(() => {
+    // Go back to file selection (within ImportStep)
+    setFocalboardFile(null);
+  }, []);
+
+  // Show Focalboard mapping step if file is selected
+  if (focalboardFile) {
+    return (
+      <FocalboardMappingStep
+        file={focalboardFile}
+        onSelect={handleFocalboardMappingSelect}
+        onBack={handleFocalboardMappingBack}
+      />
+    );
+  }
+
   return (
     <>
       <Popup.Header onBack={onBack}>
@@ -34,9 +69,12 @@ const ImportStep = React.memo(({ onSelect, onBack }) => {
         })}
       </Popup.Header>
       <Popup.Content>
-        <FilePicker accept=".json" onSelect={(file) => handleFileSelect('trello', file)}>
+        <FilePicker accept=".json" onSelect={handleTrelloFileSelect}>
           <Button fluid content={t('common.fromTrello')} icon="trello" className={styles.button} />
         </FilePicker>
+        <FilePicker accept=".jsonl" onSelect={handleFocalboardFileSelect}>
+          <Button fluid content={t('common.fromFocalboard')} icon="file" className={styles.button} />
+        </FilePicker>
       </Popup.Content>
     </>
   );
diff --git a/client/src/locales/en-US/core.js b/client/src/locales/en-US/core.js
index 34be10d1e..0bfe19797 100644
--- a/client/src/locales/en-US/core.js
+++ b/client/src/locales/en-US/core.js
@@ -109,6 +109,8 @@ export default {
       canOnlyViewBoard: 'Can only view the board.',
       cardActions_title: 'Card Actions',
       cardNotFound_title: 'Card Not Found',
+      cardsCount: "{{count}} cards",
+      cardsCount_plural: "{{count}} cards",
       cardsOnThisListAreAvailableToAllBoardMembers:
         'Cards on this list are available to all board members.',
       cardsOnThisListAreCompleteAndReadyToBeArchived:
@@ -118,6 +120,7 @@ export default {
       clientHostnameInEhlo: 'Client hostname in EHLO',
       closed: 'Closed',
       color: 'Color',
+      columns: 'Columns',
       comments: 'Comments',
       contentExceedsLimit: 'Content exceeds {{limit}}',
       contentOfThisAttachmentIsTooBigToDisplay: 'Content of this attachment is too big to display.',
@@ -192,13 +195,16 @@ export default {
       enterListTitle: 'Enter list title...',
       enterTaskDescription: 'Enter task description...',
       events: 'Events',
+      error: "Error",
       excludedEvents: 'Excluded events',
       expandTaskListsByDefault: 'Expand task lists by default',
       filterByLabels_title: 'Filter By Labels',
       filterByMembers_title: 'Filter By Members',
+      focalboardImport_title: "Focalboard Import",
       forPersonalProjects: 'For personal projects.',
       forTeamBasedProjects: 'For team-based projects.',
       fromComputer_title: 'From Computer',
+      fromFocalboard: 'From Focalboard',
       fromTrello: 'From Trello',
       fullKeyIsHiddenForSecurityReasons:
         'The full key is hidden for security reasons. Regenerate it to create a new one.',
@@ -240,6 +246,7 @@ export default {
       newUsername: 'New username',
       newVersionAvailable: 'New version available',
       newestFirst: 'Newest first',
+      none: "None",
       noApiKeyCreated: 'No API key created.',
       noBoards: 'No boards',
       noCardsFound: 'No cards found.',
@@ -255,6 +262,7 @@ export default {
       optional_inline: 'optional',
       organization: 'Organization',
       others: 'Others',
+      parsingFile: "Parsing file...",
       passwordIsSet: 'Password is set',
       phone: 'Phone',
       plankaUsesAppriseToSendNotificationsToOver100PopularServices:
@@ -290,6 +298,7 @@ export default {
       selectOrder_title: 'Select Order',
       selectPermissions_title: 'Select Permissions',
       selectProject: 'Select project',
+      selectProperty: "Select property...",
       selectRole_title: 'Select Role',
       selectType_title: 'Select Type',
       sequentialDisplayOfCards: 'Sequential display of cards.',
@@ -322,6 +331,7 @@ export default {
       typeNameToConfirm: 'Type the name to confirm.',
       typeTitleToConfirm: 'Type the title to confirm.',
       unsavedChanges: 'Unsaved changes',
+      unsupported: 'Unsupported',
       uploadFailedFileIsTooBig: 'Upload failed: File is too big.',
       uploadFailedNotEnoughStorageSpace: 'Upload failed: Not enough storage space.',
       uploadedImages: 'Uploaded images',
@@ -387,6 +397,7 @@ export default {
       archiveCards: 'Archive cards',
       archiveCards_title: 'Archive Cards',
       assignAsOwner: 'Assign as owner',
+      back: "Back",
       cancel: 'Cancel',
       copy: 'Copy',
       copyCard_title: 'Copy Card',
@@ -428,6 +439,7 @@ export default {
       deleteUser: 'Delete user',
       deleteUser_title: 'Delete User',
       deleteWebhook: 'Delete webhook',
+      deselectAll: "Deselect All",
       dismissAll: 'Dismiss all',
       download: 'Download',
       duplicateCard_title: 'Duplicate Card',
@@ -473,6 +485,7 @@ export default {
       restoreToList: 'Restore to {{list}}',
       returnToBoard: 'Return to board',
       save: 'Save',
+      selectAll: "Select All",
       sendTestEmail: 'Send test email',
       showActive: 'Show active',
       showAllAttachments: 'Show all attachments ({{hidden}} hidden)',
diff --git a/client/src/sagas/core/services/boards.js b/client/src/sagas/core/services/boards.js
index 77a405343..841b0115d 100644
--- a/client/src/sagas/core/services/boards.js
+++ b/client/src/sagas/core/services/boards.js
@@ -16,6 +16,7 @@ import ActionTypes from '../../../constants/ActionTypes';
 import ModalTypes from '../../../constants/ModalTypes';
 
 export function* createBoard(projectId, { import: boardImport, ...data }) {
+
   const localId = yield call(createLocalId);
 
   const nextData = {
@@ -40,22 +41,36 @@ export function* createBoard(projectId, { import: boardImport, ...data }) {
   let boardMemberships;
 
   try {
-    ({
-      item: board,
-      included: { boardMemberships },
-    } = yield boardImport
-      ? call(
-          request,
-          api.createBoardWithImport,
-          projectId,
-          {
-            ...nextData,
-            importType: boardImport.type,
-            importFile: boardImport.file,
-          },
-          localId,
-        )
-      : call(request, api.createBoard, projectId, nextData));
+    if (boardImport) {
+      // Build import payload
+      const importPayload = {
+        ...nextData,
+        importType: boardImport.type,
+        importFile: boardImport.file,
+      };
+
+      // Add mapping for Focalboard imports
+      if (boardImport.type === 'focalboard' && boardImport.mapping) {
+        importPayload.importMapping = JSON.stringify(boardImport.mapping);
+      }
+
+      ({
+        item: board,
+        included: { boardMemberships },
+      } = yield call(
+        request,
+        api.createBoardWithImport,
+        projectId,
+        importPayload,
+        localId,
+      ));
+    } else {
+      ({
+        item: board,
+
+        included: { boardMemberships },
+      } = yield call(request, api.createBoard, projectId, nextData));
+    }
   } catch (error) {
     yield put(actions.createBoard.failure(localId, error));
     return;
diff --git a/server/api/controllers/boards/create.js b/server/api/controllers/boards/create.js
index 049fbdc15..548e66b4b 100755
--- a/server/api/controllers/boards/create.js
+++ b/server/api/controllers/boards/create.js
@@ -49,6 +49,10 @@
  *                 type: string
  *                 format: binary
  *                 description: Import file
+*               importMapping:
+ *                 type: string
+ *                 description: JSON object with property mappings for Focalboard import
+ *                 example: '{"columnPropertyId":"...","labelPropertyId":"...","dueDatePropertyId":"...","customFieldPropertyIds":["...","..."]}'
  *               requestId:
  *                 type: string
  *                 maxLength: 128
@@ -139,6 +143,10 @@ module.exports = {
       type: 'string',
       isIn: Object.values(Board.ImportTypes),
     },
+    importMapping: {
+      type: 'json',
+      description: 'Property mappings for Focalboard import: { columnPropertyId, labelPropertyId, dueDatePropertyId, customFieldPropertyIds[] }',
+    },
     requestId: {
       type: 'string',
       isNotEmptyString: true,
@@ -200,6 +208,32 @@ module.exports = {
           type: inputs.importType,
           board: trelloBoard,
         };
+      } else if (inputs.importType === Board.ImportTypes.FOCALBOARD) {
+        let mapping = inputs.importMapping || {};
+
+        if (typeof mapping === 'string') {
+          try {
+            mapping = JSON.parse(mapping);
+          } catch (e) {
+            console.error('Failed to parse importMapping:', e);
+            mapping = {};
+          }
+        }
+
+        const focalboardData = await sails.helpers.boards
+          .processUploadedFocalboardImportFile.with({
+            file,
+            columnPropertyId: mapping.columnPropertyId,
+            labelPropertyId: mapping.labelPropertyId,
+            dueDatePropertyId: mapping.dueDatePropertyId,
+            customFieldPropertyIds: mapping.customFieldPropertyIds || [],
+          })
+          .intercept('invalidFile', () => Errors.INVALID_IMPORT_FILE);
+
+        boardImport = {
+          type: inputs.importType,
+          data: focalboardData,
+        };
       }
     }
 
diff --git a/server/api/controllers/focalboard/preview.js b/server/api/controllers/focalboard/preview.js
new file mode 100644
index 000000000..621bfe0aa
--- /dev/null
+++ b/server/api/controllers/focalboard/preview.js
@@ -0,0 +1,202 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @swagger
+ * /focalboard/preview:
+ *   post:
+ *     summary: Preview Focalboard import file
+ *     description: Parses a Focalboard JSONL export file and returns available properties for user selection before import.
+ *     tags:
+ *       - Focalboard
+ *     operationId: previewFocalboardImport
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         multipart/form-data:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - file
+ *             properties:
+ *               file:
+ *                 type: string
+ *                 format: binary
+ *                 description: Focalboard JSONL export file
+ *     responses:
+ *       200:
+ *         description: File parsed successfully
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               required:
+ *                 - board
+ *                 - properties
+ *                 - views
+ *               properties:
+ *                 board:
+ *                   type: object
+ *                   properties:
+ *                     id:
+ *                       type: string
+ *                     title:
+ *                       type: string
+ *                     description:
+ *                       type: string
+ *                 properties:
+ *                   type: array
+ *                   description: Available card properties for mapping
+ *                   items:
+ *                     type: object
+ *                     properties:
+ *                       id:
+ *                         type: string
+ *                       name:
+ *                         type: string
+ *                       type:
+ *                         type: string
+ *                         enum: [text, number, select, multiSelect, date, person, multiPerson, file, checkbox, url, email, phone, createdTime, createdBy, updatedTime, updatedBy, unknown]
+ *                       options:
+ *                         type: array
+ *                         description: Options for select/multiSelect properties
+ *                         items:
+ *                           type: object
+ *                           properties:
+ *                             id:
+ *                               type: string
+ *                             value:
+ *                               type: string
+ *                             color:
+ *                               type: string
+ *                 views:
+ *                   type: array
+ *                   description: Available views (for column property detection)
+ *                   items:
+ *                     type: object
+ *                     properties:
+ *                       id:
+ *                         type: string
+ *                       title:
+ *                         type: string
+ *                       type:
+ *                         type: string
+ *                       groupById:
+ *                         type: string
+ *                         description: Property ID used for column grouping in this view
+ *                 stats:
+ *                   type: object
+ *                   properties:
+ *                     totalCards:
+ *                       type: number
+ *                     totalTextBlocks:
+ *                       type: number
+ *       401:
+ *         $ref: '#/components/responses/Unauthorized'
+ *       422:
+ *         description: File upload or parsing error
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 code:
+ *                   type: string
+ *                 message:
+ *                   type: string
+ */
+
+const Errors = {
+  NO_FILE_WAS_UPLOADED: {
+    noFileWasUploaded: 'No file was uploaded',
+  },
+  INVALID_FILE: {
+    invalidFile: 'Invalid Focalboard export file',
+  },
+};
+
+module.exports = {
+  inputs: {},
+
+  exits: {
+    noFileWasUploaded: {
+      responseType: 'unprocessableEntity',
+    },
+    invalidFile: {
+      responseType: 'unprocessableEntity',
+    },
+    uploadError: {
+      responseType: 'unprocessableEntity',
+    },
+  },
+
+  async fn(inputs, exits) {
+    // Require authentication
+    const { currentUser } = this.req;
+    if (!currentUser) {
+      throw { unauthorized: 'Unauthorized' };
+    }
+
+    // Receive uploaded file
+    let files;
+    try {
+      files = await sails.helpers.utils.receiveFile(this.req.file('file'), false);
+    } catch (error) {
+      return exits.uploadError(error.message);
+    }
+
+    if (files.length === 0) {
+      throw Errors.NO_FILE_WAS_UPLOADED;
+    }
+
+    const file = _.last(files);
+
+    // Parse the Focalboard file
+    let focalboardData;
+    try {
+      focalboardData = await sails.helpers.boards.parseFocalboardFile.with({
+        file,
+        previewOnly: true,
+      });
+    } catch (error) {
+      if (error === 'invalidFile' || error.code === 'invalidFile') {
+        throw Errors.INVALID_FILE;
+      }
+      throw error;
+    }
+
+    const { board, views, cardCount, textBlockCount } = focalboardData;
+
+    // Build response with properties for user selection
+    const properties = (board.cardProperties || []).map((prop) => ({
+      id: prop.id,
+      name: prop.name,
+      type: prop.type,
+      options: prop.options || [],
+    }));
+
+    // Extract view info for column property detection
+    const viewsInfo = views.map((view) => ({
+      id: view.id,
+      title: view.title,
+      type: view.fields?.viewType || 'unknown',
+      groupById: view.fields?.groupById || null,
+    }));
+
+    return exits.success({
+      board: {
+        id: board.id,
+        title: board.title,
+        description: board.description || null,
+      },
+      properties,
+      views: viewsInfo,
+      stats: {
+        totalCards: cardCount,
+        totalTextBlocks: textBlockCount,
+      },
+    });
+  },
+};
diff --git a/server/api/helpers/boards/convert-focalboard-label-color.js b/server/api/helpers/boards/convert-focalboard-label-color.js
new file mode 100644
index 000000000..0660d60e2
--- /dev/null
+++ b/server/api/helpers/boards/convert-focalboard-label-color.js
@@ -0,0 +1,38 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @description :: Converts Focalboard color names to Planka label colors.
+ */
+
+module.exports = {
+  sync: true,
+
+  inputs: {
+    focalboardColor: {
+      type: 'string',
+      description: 'Focalboard color name (e.g., "propColorYellow")',
+      required: true,
+    },
+  },
+
+  fn(inputs) {
+    const colorMap = {
+      propColorDefault: 'desert-sand',
+      propColorGray: 'grey-stone',
+      propColorBrown: 'light-cocoa',
+      propColorOrange: 'pumpkin-orange',
+      propColorYellow: 'egg-yellow',
+      propColorGreen: 'fresh-salad',
+      propColorTeal: 'turquoise-sea',
+      propColorBlue: 'lagoon-blue',
+      propColorPurple: 'sugar-plum',
+      propColorPink: 'pink-tulip',
+      propColorRed: 'berry-red',
+    };
+
+    return colorMap[inputs.focalboardColor] || 'desert-sand';
+  },
+};
diff --git a/server/api/helpers/boards/create-one.js b/server/api/helpers/boards/create-one.js
index a09a7252d..dec257c86 100644
--- a/server/api/helpers/boards/create-one.js
+++ b/server/api/helpers/boards/create-one.js
@@ -88,6 +88,10 @@ module.exports = {
       await sails.helpers.boards.importFromTrello(board, lists, inputs.import.board);
     }
 
+    if (inputs.import && inputs.import.type === Board.ImportTypes.FOCALBOARD) {
+      await sails.helpers.boards.importFromFocalboard(board, lists, inputs.import.data);
+    }
+
     scoper.board = board;
     scoper.boardMemberships = [boardMembership];
 
diff --git a/server/api/helpers/boards/group-focalboard-cards-by-list.js b/server/api/helpers/boards/group-focalboard-cards-by-list.js
new file mode 100644
index 000000000..365727be1
--- /dev/null
+++ b/server/api/helpers/boards/group-focalboard-cards-by-list.js
@@ -0,0 +1,147 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @description :: Groups Focalboard cards by their target Planka list.
+ *                 Processes cards in cardOrder first, then remaining cards.
+ */
+
+module.exports = {
+  sync: true,
+
+  inputs: {
+    focalboardCards: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard card blocks',
+    },
+    cardOrder: {
+      type: 'ref',
+      required: true,
+      description: 'Array of card IDs in display order from Kanban view',
+    },
+    columnPropertyId: {
+      type: 'string',
+      required: true,
+      description: 'Focalboard property ID used for column assignment',
+    },
+    listIdByOptionId: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Focalboard option ID to Planka list ID',
+    },
+    unorderedListId: {
+      type: 'string',
+      required: true,
+      description: 'Planka list ID for cards without column assignment',
+    },
+    unorderedListName: {
+      type: 'string',
+      required: true,
+      description: 'Name of the unordered list (for logging)',
+    },
+    columnOptions: {
+      type: 'ref',
+      required: true,
+      description: 'Array of column property options (for logging)',
+    },
+  },
+
+  fn(inputs) {
+    const {
+      focalboardCards,
+      cardOrder,
+      columnPropertyId,
+      listIdByOptionId,
+      unorderedListId,
+      unorderedListName,
+      columnOptions,
+    } = inputs;
+
+    console.log('');
+    console.log('--- Grouping Cards by Column ---');
+    console.log(`Cards in cardOrder: ${cardOrder.length}`);
+
+    // Group cards by their column assignment
+    const cardsByListId = {};
+
+    // Initialize lists
+    Object.values(listIdByOptionId).forEach((listId) => {
+      cardsByListId[listId] = [];
+    });
+    cardsByListId[unorderedListId] = [];
+
+    // Map Focalboard card IDs to card objects
+    const focalboardCardById = {};
+    focalboardCards.forEach((card) => {
+      focalboardCardById[card.id] = card;
+    });
+
+    // Process cards in cardOrder first (maintains order)
+    let processedFromCardOrder = 0;
+    let cardsWithoutColumn = 0;
+    const processedCardIds = new Set();
+
+    cardOrder.forEach((cardId) => {
+      const card = focalboardCardById[cardId];
+      if (!card) return;
+
+      processedCardIds.add(cardId);
+
+      const columnValue = card.fields?.properties?.[columnPropertyId];
+      const listId = listIdByOptionId[columnValue];
+
+      if (listId) {
+        cardsByListId[listId].push(card);
+      } else {
+        cardsByListId[unorderedListId].push(card);
+        cardsWithoutColumn += 1;
+      }
+
+      processedFromCardOrder += 1;
+    });
+
+    console.log(`Cards processed from cardOrder: ${processedFromCardOrder}`);
+
+    // Process cards not in cardOrder - place by column value, or Unordered if no column
+    let cardsNotInCardOrder = 0;
+    focalboardCards.forEach((card) => {
+      if (!processedCardIds.has(card.id)) {
+        const columnValue = card.fields?.properties?.[columnPropertyId];
+        const listId = listIdByOptionId[columnValue];
+
+        if (listId) {
+          cardsByListId[listId].push(card);
+        } else {
+          cardsByListId[unorderedListId].push(card);
+          cardsWithoutColumn += 1;
+        }
+
+        cardsNotInCardOrder += 1;
+      }
+    });
+
+    console.log(`Cards not in cardOrder (added to "${unorderedListName}"): ${cardsNotInCardOrder}`);
+    console.log(`Cards without column assignment: ${cardsWithoutColumn}`);
+
+    // Log card distribution
+    console.log('');
+    console.log('Card distribution by list:');
+    Object.entries(cardsByListId).forEach(([listId, cards]) => {
+      // Find list name
+      let listName = unorderedListName;
+      for (const [optionId, id] of Object.entries(listIdByOptionId)) {
+        if (id === listId) {
+          const option = columnOptions.find((o) => o.id === optionId);
+          listName = option?.value || 'Unknown';
+          break;
+        }
+      }
+      console.log(`  ${listName}: ${cards.length} cards`);
+    });
+
+    return cardsByListId;
+  },
+};
diff --git a/server/api/helpers/boards/import-focalboard-cards.js b/server/api/helpers/boards/import-focalboard-cards.js
new file mode 100644
index 000000000..4e1cce293
--- /dev/null
+++ b/server/api/helpers/boards/import-focalboard-cards.js
@@ -0,0 +1,235 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+const { POSITION_GAP } = require('../../../constants');
+
+/**
+ * @description :: Creates Planka cards from grouped Focalboard card data.
+ *                 Handles descriptions, due dates, label assignments, and custom field values.
+ */
+
+module.exports = {
+  inputs: {
+    boardId: {
+      type: 'string',
+      required: true,
+      description: 'Planka board ID to create cards in',
+    },
+    cardsByListId: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Planka list ID to array of Focalboard cards',
+    },
+    textBlocks: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard text blocks (for descriptions)',
+    },
+    dueDatePropertyId: {
+      type: 'string',
+      allowNull: true,
+      description: 'Focalboard property ID for due date (null if not found)',
+    },
+    labelPropertyId: {
+      type: 'string',
+      allowNull: true,
+      description: 'Focalboard property ID for labels (null if not found)',
+    },
+    labelIdByFocalboardLabelId: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Focalboard label ID to Planka label ID',
+    },
+    listIdByOptionId: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Focalboard option ID to Planka list ID (for logging)',
+    },
+    columnOptions: {
+      type: 'ref',
+      required: true,
+      description: 'Array of column property options (for logging)',
+    },
+    unorderedListName: {
+      type: 'string',
+      required: true,
+      description: 'Name of the unordered list (for logging)',
+    },
+    customFieldGroup: {
+      type: 'ref',
+      description: 'Planka CustomFieldGroup for this board (null if no custom fields)',
+    },
+    customFieldIdByFocalboardPropertyId: {
+      type: 'ref',
+      description: 'Map of Focalboard property ID to Planka custom field ID',
+    },
+  },
+
+  async fn(inputs) {
+    const {
+      boardId,
+      cardsByListId,
+      textBlocks,
+      dueDatePropertyId,
+      labelPropertyId,
+      labelIdByFocalboardLabelId,
+      listIdByOptionId,
+      columnOptions,
+      unorderedListName,
+      customFieldGroup,
+      customFieldIdByFocalboardPropertyId,
+    } = inputs;
+
+    console.log('');
+    console.log('--- Importing Cards ---');
+
+    // Build text block lookup by parent ID
+    const textBlocksByParentId = {};
+    textBlocks.forEach((block) => {
+      if (!textBlocksByParentId[block.parentId]) {
+        textBlocksByParentId[block.parentId] = [];
+      }
+      textBlocksByParentId[block.parentId].push(block);
+    });
+
+    const stats = {
+      totalCardsImported: 0,
+      cardsWithoutTitle: 0,
+      cardsWithDescriptions: 0,
+      cardsWithLabels: 0,
+      cardsWithDueDate: 0,
+      cardsWithCustomFields: 0,
+      customFieldValuesCreated: 0,
+    };
+
+    const hasCustomFields = customFieldGroup && customFieldIdByFocalboardPropertyId &&
+      Object.keys(customFieldIdByFocalboardPropertyId).length > 0;
+
+    // Process each list
+    for (const [listId, cards] of Object.entries(cardsByListId)) {
+      if (cards.length === 0) continue;
+
+      // Find list name for logging
+      let listName = unorderedListName;
+      for (const [optionId, id] of Object.entries(listIdByOptionId)) {
+        if (id === listId) {
+          const option = columnOptions.find((o) => o.id === optionId);
+          listName = option?.value || 'Unknown';
+          break;
+        }
+      }
+
+      console.log(`Processing list "${listName}"...`);
+
+      await Promise.all(
+        cards.map(async (focalboardCard, index) => {
+          // Build description from text blocks
+          const cardTextBlocks = textBlocksByParentId[focalboardCard.id] || [];
+          const descriptionParts = cardTextBlocks
+            .map((block) => block.title?.trim())
+            .filter((text) => text);
+
+          const description = descriptionParts.length > 0 ? descriptionParts.join('\n\n') : null;
+
+          if (description) {
+            stats.cardsWithDescriptions += 1;
+          }
+
+          // Extract due date from Focalboard properties
+          let dueDate = null;
+          if (dueDatePropertyId) {
+            const dueDateRaw = focalboardCard.fields?.properties?.[dueDatePropertyId];
+            dueDate = sails.helpers.boards.parseFocalboardDate(dueDateRaw);
+
+            if (dueDate) {
+              stats.cardsWithDueDate += 1;
+            }
+          }
+
+          // Create card
+          const cardValues = {
+            boardId,
+            listId,
+            type: Card.Types.PROJECT,
+            position: POSITION_GAP * (index + 1),
+            name: focalboardCard.title?.trim() || 'Untitled',
+            description,
+            dueDate,
+            isDueCompleted: dueDate ? false : null,
+            listChangedAt: new Date(focalboardCard.updateAt).toISOString(),
+          };
+
+          if (!focalboardCard.title?.trim()) {
+            stats.cardsWithoutTitle += 1;
+          }
+
+          const { id: cardId } = await Card.qm.createOne(cardValues);
+          stats.totalCardsImported += 1;
+
+          // Assign labels to card
+          if (labelPropertyId) {
+            const cardLabelIds = focalboardCard.fields?.properties?.[labelPropertyId];
+
+            if (Array.isArray(cardLabelIds) && cardLabelIds.length > 0) {
+              await Promise.all(
+                cardLabelIds.map(async (focalboardLabelId) => {
+                  const plankaLabelId = labelIdByFocalboardLabelId[focalboardLabelId];
+
+                  if (plankaLabelId) {
+                    await CardLabel.qm.createOne({
+                      cardId,
+                      labelId: plankaLabelId,
+                    });
+                  }
+                }),
+              );
+
+              stats.cardsWithLabels += 1;
+            }
+          }
+
+          // Create custom field values
+          if (hasCustomFields) {
+            let cardHasCustomFields = false;
+
+            await Promise.all(
+              Object.entries(customFieldIdByFocalboardPropertyId).map(
+                async ([focalboardPropertyId, plankaCustomFieldId]) => {
+                  const rawValue = focalboardCard.fields?.properties?.[focalboardPropertyId];
+
+                  // Skip empty values
+                  if (rawValue === null || rawValue === undefined || rawValue === '') {
+                    return;
+                  }
+
+                  // Convert value to string (Planka stores all custom field values as strings)
+                  const content = String(rawValue);
+
+                  await CustomFieldValue.qm.createOrUpdateOne({
+                    cardId,
+                    customFieldGroupId: customFieldGroup.id,
+                    customFieldId: plankaCustomFieldId,
+                    content,
+                  });
+
+                  stats.customFieldValuesCreated += 1;
+                  cardHasCustomFields = true;
+                },
+              ),
+            );
+
+            if (cardHasCustomFields) {
+              stats.cardsWithCustomFields += 1;
+            }
+          }
+        }),
+      );
+
+      console.log(`Created ${cards.length} cards`);
+    }
+
+    return stats;
+  },
+};
diff --git a/server/api/helpers/boards/import-focalboard-custom-fields.js b/server/api/helpers/boards/import-focalboard-custom-fields.js
new file mode 100644
index 000000000..c4edf66b9
--- /dev/null
+++ b/server/api/helpers/boards/import-focalboard-custom-fields.js
@@ -0,0 +1,79 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+const { POSITION_GAP } = require('../../../constants');
+
+/**
+ * @description :: Creates Planka custom field group and fields from Focalboard properties.
+ *                 Returns the group and field mapping for use during card import.
+ */
+
+// Custom field group name in Planka
+const CUSTOM_FIELD_GROUP_NAME = 'Custom fields';
+
+module.exports = {
+  inputs: {
+    boardId: {
+      type: 'string',
+      required: true,
+      description: 'Planka board ID to create custom fields in',
+    },
+    customFieldProperties: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard property objects to import as custom fields',
+    },
+  },
+
+  async fn(inputs) {
+    const { boardId, customFieldProperties } = inputs;
+
+    console.log('');
+    console.log('--- Creating Custom Fields ---');
+
+    if (!customFieldProperties || customFieldProperties.length === 0) {
+      console.log('No custom fields to import');
+      return {
+        customFieldGroup: null,
+        customFieldIdByFocalboardPropertyId: {},
+      };
+    }
+
+    console.log(`Custom fields to import: ${customFieldProperties.length}`);
+
+
+    // Step 1: Create CustomFieldGroup for the board
+    const customFieldGroup = await CustomFieldGroup.qm.createOne({
+      boardId,
+      position: POSITION_GAP,
+      name: CUSTOM_FIELD_GROUP_NAME,
+    });
+
+    console.log(`Created custom field group: "${CUSTOM_FIELD_GROUP_NAME}" (${customFieldGroup.id})`);
+
+    // Step 2: Create CustomField entries for each configured property
+    const customFieldIdByFocalboardPropertyId = {};
+
+    await Promise.all(
+      customFieldProperties.map(async (focalboardProperty, index) => {
+        const customField = await CustomField.qm.createOne({
+          customFieldGroupId: customFieldGroup.id,
+          position: POSITION_GAP * (index + 1),
+          name: focalboardProperty.name,
+        });
+
+        customFieldIdByFocalboardPropertyId[focalboardProperty.id] = customField.id;
+        console.log(`  Created custom field: "${focalboardProperty.name}" (${focalboardProperty.type})`);
+      }),
+    );
+
+    console.log(`Total custom fields created: ${Object.keys(customFieldIdByFocalboardPropertyId).length}`);
+
+    return {
+      customFieldGroup,
+      customFieldIdByFocalboardPropertyId,
+    };
+  },
+};
diff --git a/server/api/helpers/boards/import-focalboard-labels.js b/server/api/helpers/boards/import-focalboard-labels.js
new file mode 100644
index 000000000..93be0d24c
--- /dev/null
+++ b/server/api/helpers/boards/import-focalboard-labels.js
@@ -0,0 +1,57 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+const { POSITION_GAP } = require('../../../constants');
+
+/**
+ * @description :: Creates Planka labels from Focalboard label data.
+ */
+
+module.exports = {
+  inputs: {
+    boardId: {
+      type: 'string',
+      required: true,
+      description: 'Planka board ID to create labels in',
+    },
+    focalboardLabels: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard label options',
+    },
+  },
+
+  async fn(inputs) {
+    const { boardId, focalboardLabels } = inputs;
+
+    console.log('');
+    console.log('--- Creating Labels ---');
+
+    const labelIdByFocalboardLabelId = {};
+
+    if (focalboardLabels.length > 0) {
+      await Promise.all(
+        focalboardLabels.map(async (focalboardLabel, index) => {
+          const plankaColor = sails.helpers.boards.convertFocalboardLabelColor(focalboardLabel.color);
+
+          const { id } = await Label.qm.createOne({
+            boardId,
+            position: POSITION_GAP * (index + 1),
+            name: focalboardLabel.value || null,
+            color: plankaColor,
+          });
+
+          labelIdByFocalboardLabelId[focalboardLabel.id] = id;
+        }),
+      );
+    } else {
+      console.log('No labels to import');
+    }
+
+    console.log(`Total labels created: ${Object.keys(labelIdByFocalboardLabelId).length}`);
+
+    return labelIdByFocalboardLabelId;
+  },
+};
diff --git a/server/api/helpers/boards/import-focalboard-lists.js b/server/api/helpers/boards/import-focalboard-lists.js
new file mode 100644
index 000000000..aef3f20b7
--- /dev/null
+++ b/server/api/helpers/boards/import-focalboard-lists.js
@@ -0,0 +1,79 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+const { POSITION_GAP } = require('../../../constants');
+
+/**
+ * @description :: Creates Planka lists from Focalboard column options.
+ */
+
+module.exports = {
+  inputs: {
+    boardId: {
+      type: 'string',
+      required: true,
+      description: 'Planka board ID to create lists in',
+    },
+    visibleOptionIds: {
+      type: 'ref',
+      required: true,
+      description: 'Array of visible column option IDs from Kanban view',
+    },
+    columnOptions: {
+      type: 'ref',
+      required: true,
+      description: 'Array of column property options from Focalboard board',
+    },
+  },
+
+  async fn(inputs) {
+    const { boardId, visibleOptionIds, columnOptions } = inputs;
+
+    console.log('');
+    console.log('--- Creating Lists ---');
+    console.log(`Visible columns: ${visibleOptionIds.length}`);
+
+    const listIdByOptionId = {};
+
+    await Promise.all(
+      visibleOptionIds.map(async (optionId, index) => {
+        const option = columnOptions.find((opt) => opt.id === optionId);
+
+        if (!option) {
+          console.log(`  [${index}] Option not found: ${optionId}`);
+          return;
+        }
+
+        const { id } = await List.qm.createOne({
+          boardId,
+          type: List.Types.ACTIVE,
+          position: POSITION_GAP * (index + 1),
+          name: option.value,
+        });
+
+        listIdByOptionId[optionId] = id;
+        console.log(`  [${index}] Created list: "${option.value}" (position: ${POSITION_GAP * (index + 1)})`);
+      }),
+    );
+
+    console.log(`  ✓ Created ${Object.keys(listIdByOptionId).length} lists`);
+
+    // Create an "Unordered" list for cards not in cardOrder or without column
+    const unorderedListName = 'Unordered';
+    const { id: unorderedListId } = await List.qm.createOne({
+      boardId,
+      type: List.Types.ACTIVE,
+      position: POSITION_GAP * (visibleOptionIds.length + 1),
+      name: unorderedListName,
+    });
+    console.log(`Created "${unorderedListName}" list (position: ${POSITION_GAP * (visibleOptionIds.length + 1)})`);
+
+    return {
+      listIdByOptionId,
+      unorderedListId,
+      unorderedListName,
+    };
+  },
+};
diff --git a/server/api/helpers/boards/import-from-focalboard.js b/server/api/helpers/boards/import-from-focalboard.js
new file mode 100644
index 000000000..eb4838c2b
--- /dev/null
+++ b/server/api/helpers/boards/import-from-focalboard.js
@@ -0,0 +1,158 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @description :: Main orchestrator for Focalboard import.
+ *                 Coordinates labels, lists, cards, and custom fields import.
+ */
+
+module.exports = {
+  inputs: {
+    board: {
+      type: 'ref',
+      required: true,
+    },
+    lists: {
+      type: 'ref',
+      required: true,
+    },
+    focalboardData: {
+      type: 'json',
+      required: true,
+    },
+  },
+
+  async fn(inputs) {
+    const {
+      board: boardBlock,
+      views,
+      cards: focalboardCards,
+      textBlocks,
+      // User selections (from processUploadedFocalboardImportFile)
+      columnProperty,
+      labels: focalboardLabels,
+      labelPropertyId,
+      dueDatePropertyId,
+      customFieldProperties,
+    } = inputs.focalboardData;
+
+    // Find the Kanban view
+    const kanbanView = views.find((view) => view.fields.viewType === 'board');
+    if (!kanbanView) {
+      throw new Error('No Kanban view found in Focalboard data');
+    }
+
+    console.log(`Using Kanban view: ${kanbanView.title}`);
+    console.log(`Column property: ${columnProperty.name} (${columnProperty.type})`);
+    console.log(`Total column options: ${columnProperty.options.length}`);
+
+    if (labelPropertyId) {
+      console.log(`Label property ID: ${labelPropertyId}`);
+      console.log(`Total labels: ${focalboardLabels.length}`);
+    } else {
+      console.log('No label property selected');
+    }
+
+    if (dueDatePropertyId) {
+      console.log(`Due date property ID: ${dueDatePropertyId}`);
+    } else {
+      console.log('No due date property selected');
+    }
+
+    if (customFieldProperties && customFieldProperties.length > 0) {
+      console.log(`Custom fields to import: ${customFieldProperties.length}`);
+      customFieldProperties.forEach((p) => console.log(`  - ${p.name} (${p.type})`));
+    } else {
+      console.log('No custom fields selected');
+    }
+
+    // =====================================================
+    // IMPORT LABELS
+    // =====================================================
+
+    const labelIdByFocalboardLabelId = await sails.helpers.boards.importFocalboardLabels(
+      inputs.board.id,
+      focalboardLabels || [],
+    );
+
+    // =====================================================
+    // LISTS SECTION
+    // =====================================================
+    const { listIdByOptionId, unorderedListId, unorderedListName } =
+      await sails.helpers.boards.importFocalboardLists(
+        inputs.board.id,
+        kanbanView.fields?.visibleOptionIds || [],
+        columnProperty.options,
+      );
+
+    // =====================================================
+    // GROUP CARDS BY LIST
+    // =====================================================
+
+    const columnPropertyId = columnProperty.id;
+
+    const cardsByListId = sails.helpers.boards.groupFocalboardCardsByList(
+      focalboardCards,
+      kanbanView.fields.cardOrder || [],
+      columnPropertyId,
+      listIdByOptionId,
+      unorderedListId,
+      unorderedListName,
+      columnProperty.options,
+    );
+
+    // =====================================================
+    // IMPORT CUSTOM FIELDS
+    // =====================================================
+
+    let customFieldGroup = null;
+    let customFieldIdByFocalboardPropertyId = {};
+
+    if (customFieldProperties && customFieldProperties.length > 0) {
+      const result = await sails.helpers.boards.importFocalboardCustomFields(
+        inputs.board.id,
+        customFieldProperties,
+      );
+      customFieldGroup = result.customFieldGroup;
+      customFieldIdByFocalboardPropertyId = result.customFieldIdByFocalboardPropertyId;
+    }
+
+    // =====================================================
+    // IMPORT CARDS
+    // =====================================================
+
+    const stats = await sails.helpers.boards.importFocalboardCards(
+      inputs.board.id,
+      cardsByListId,
+      textBlocks,
+      dueDatePropertyId,
+      labelPropertyId,
+      labelIdByFocalboardLabelId,
+      listIdByOptionId,
+      columnProperty.options,
+      unorderedListName,
+      customFieldGroup,
+      customFieldIdByFocalboardPropertyId,
+    );
+
+    // =====================================================
+    // SUMMARY
+    // =====================================================
+
+    console.log('');
+    console.log('=== Import Complete ===');
+    console.log(`Total cards imported: ${stats.totalCardsImported}`);
+    console.log(`Cards without title (named "Untitled"): ${stats.cardsWithoutTitle}`);
+    console.log(`Cards with descriptions: ${stats.cardsWithDescriptions}`);
+    console.log(`Cards with labels: ${stats.cardsWithLabels}`);
+    console.log(`Cards with due date: ${stats.cardsWithDueDate}`);
+    console.log(`Cards with custom fields: ${stats.cardsWithCustomFields}`);
+    console.log(`Custom field values created: ${stats.customFieldValuesCreated}`);
+    console.log(`Labels created: ${Object.keys(labelIdByFocalboardLabelId).length}`);
+    console.log(`Lists created: ${Object.keys(listIdByOptionId).length + 1} (including "${unorderedListName}")`);
+    console.log(`Custom fields created: ${Object.keys(customFieldIdByFocalboardPropertyId).length}`);
+    console.log('');
+  },
+};
diff --git a/server/api/helpers/boards/parse-focalboard-date.js b/server/api/helpers/boards/parse-focalboard-date.js
new file mode 100644
index 000000000..d10ff9816
--- /dev/null
+++ b/server/api/helpers/boards/parse-focalboard-date.js
@@ -0,0 +1,35 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @description :: Parses Focalboard date property value to ISO string.
+ *                 Focalboard stores dates as JSON string: '{"to":1633002840000}' or '{"from":1633002840000}'
+ */
+
+module.exports = {
+  sync: true,
+
+  inputs: {
+    dateValue: {
+      type: 'string',
+      description: 'Focalboard date value as JSON string (e.g., \'{"to":1633002840000}\')',
+    },
+  },
+
+  fn(inputs) {
+    if (!inputs.dateValue) return null;
+
+    try {
+      const dateJson = JSON.parse(inputs.dateValue);
+      const timestamp = dateJson.to || dateJson.from;
+
+      if (!timestamp) return null;
+
+      return new Date(timestamp).toISOString();
+    } catch (error) {
+      return null;
+    }
+  },
+};
diff --git a/server/api/helpers/boards/parse-focalboard-file.js b/server/api/helpers/boards/parse-focalboard-file.js
new file mode 100644
index 000000000..06c6d65dd
--- /dev/null
+++ b/server/api/helpers/boards/parse-focalboard-file.js
@@ -0,0 +1,171 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+const fs = require('fs');
+const { rimraf } = require('rimraf');
+const readline = require('readline');
+
+/**
+ * @description :: Parses a Focalboard JSONL export file and returns structured data.
+ *                 Used by both preview endpoint and import flow.
+ */
+
+module.exports = {
+  inputs: {
+    file: {
+      type: 'json',
+      required: true,
+      description: 'Uploaded file object with fd (file descriptor)',
+    },
+    previewOnly: {
+      type: 'boolean',
+      defaultsTo: false,
+      description: 'If true, only parse board and views (faster for preview)',
+    },
+  },
+
+  exits: {
+    invalidFile: {},
+  },
+
+  async fn(inputs) {
+    console.log('');
+    console.log('=== Parsing Focalboard JSONL File ===');
+    const { previewOnly } = inputs;
+
+    const fileStream = fs.createReadStream(inputs.file.fd);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity,
+    });
+
+    const data = {
+      board: null,
+      views: [],
+      cards: [],
+      textBlocks: [],
+    };
+
+    let lineCount = 0;
+    let emptyLines = 0;
+    let parseErrors = 0;
+    let cardCount = 0;
+    let textBlockCount = 0;
+    const unknownBlockTypes = new Set();
+
+    try {
+      for await (const line of rl) {
+        lineCount++;
+
+        if (!line.trim()) {
+          emptyLines++;
+          continue;
+        }
+
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch (error) {
+          parseErrors++;
+          console.warn(`Parse error on line ${lineCount}: ${error.message}`);
+          await rimraf(inputs.file.fd);
+          throw 'invalidFile';
+        }
+
+        // Focalboard exports have two formats:
+        // 1. Board: {"type":"board","data":{...}}
+        // 2. Blocks: {"type":"block","data":{...}}
+
+        let block;
+        if (parsed.type === 'board' && parsed.data) {
+          block = parsed.data;
+          data.board = block;
+          console.log(`Found board: "${block.title}"`);
+          continue;
+        } else if (parsed.type === 'block' && parsed.data) {
+          block = parsed.data;
+        } else {
+          // console.warn(`Skipping line ${lineCount}: not a valid structure (type: ${parsed.type})`);
+          continue;
+        }
+
+        switch (block.type) {
+          case 'view':
+            data.views.push(block);
+            break;
+          case 'card':
+            if (previewOnly) {
+              cardCount++;
+            } else {
+              data.cards.push(block);
+            }
+            break;
+          case 'text':
+            if (previewOnly) {
+              textBlockCount++;
+            } else {
+              data.textBlocks.push(block);
+            }
+          default:
+            unknownBlockTypes.add(block.type);
+            break;
+        }
+      }
+    } catch (error) {
+      await rimraf(inputs.file.fd);
+      if (error === 'invalidFile') {
+        throw error;
+      }
+      console.error('Unexpected error:', error);
+      throw 'invalidFile';
+    }
+
+    await rimraf(inputs.file.fd);
+
+    console.log('');
+    console.log('--- Parsing Summary ---');
+    console.log(`Total lines: ${lineCount}`);
+    console.log(`Empty lines: ${emptyLines}`);
+    console.log(`Board: ${data.board ? data.board.title : 'NOT FOUND'}`);
+    console.log(`Views: ${data.views.length}`);
+    console.log(`Cards: ${data.cards.length}`);
+    console.log(`Text blocks: ${data.textBlocks.length}`);
+
+    if (unknownBlockTypes.size > 0) {
+      console.log(`Unknown block types (ignored): ${Array.from(unknownBlockTypes).join(', ')}`);
+    }
+
+    if (parseErrors > 0) {
+      console.warn(`Parse errors: ${parseErrors}`);
+    }
+
+    // Validate minimum required data
+    if (!data.board) {
+      console.error('ERROR: No board block found');
+      throw 'invalidFile';
+    }
+
+    if (data.views.length === 0) {
+      console.error('ERROR: No view blocks found');
+      throw 'invalidFile';
+    }
+
+    // For full parsing, validate cards exist
+    if (!previewOnly && data.cards.length === 0) {
+      throw 'invalidFile';
+    }
+
+    // In preview mode, add counts to data
+    if (previewOnly) {
+      data.cardCount = cardCount;
+      data.textBlockCount = textBlockCount;
+    }
+
+    console.log('✓ File parsed successfully');
+    console.log('');
+
+    return data;
+  },
+}
diff --git a/server/api/helpers/boards/process-uploaded-focalboard-import-file.js b/server/api/helpers/boards/process-uploaded-focalboard-import-file.js
new file mode 100644
index 000000000..879802136
--- /dev/null
+++ b/server/api/helpers/boards/process-uploaded-focalboard-import-file.js
@@ -0,0 +1,109 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @description :: Processes a Focalboard JSONL file for import, applying user's property selections.
+ */
+
+module.exports = {
+  inputs: {
+    file: {
+      type: 'json',
+      required: true,
+      description: 'Uploaded file object',
+    },
+    columnPropertyId: {
+      type: 'string',
+      description: 'Focalboard property ID to use for columns/lists',
+    },
+    labelPropertyId: {
+      type: 'string',
+      description: 'Focalboard property ID to use for labels',
+    },
+    dueDatePropertyId: {
+      type: 'string',
+      description: 'Focalboard property ID to use for due dates',
+    },
+    customFieldPropertyIds: {
+      type: 'ref',
+      description: 'Array of Focalboard property IDs to import as custom fields',
+    },
+  },
+
+  exits: {
+    invalidFile: {},
+  },
+
+  async fn(inputs) {
+
+    const {
+      file,
+      columnPropertyId,
+      labelPropertyId,
+      dueDatePropertyId,
+      customFieldPropertyIds,
+    } = inputs;
+
+    const data = await sails.helpers.boards
+    .parseFocalboardFile(file)
+    .intercept('invalidFile', () => 'invalidFile');
+    const { board, views, cards, textBlocks } = data;
+
+    // Find the Kanban view
+    const kanbanView = views.find((view) => view.fields?.viewType === 'board');
+    if (!kanbanView) {
+      console.error('ERROR: No Kanban view found');
+      throw 'invalidFile';
+    }
+
+    // Determine column property (user selection or from view)
+    const effectiveColumnPropertyId = columnPropertyId || kanbanView.fields?.groupById;
+    const columnProperty = board.cardProperties?.find((p) => p.id === effectiveColumnPropertyId);
+
+    if (!columnProperty) {
+      console.error('ERROR: Column property not found');
+      throw 'invalidFile';
+    }
+
+    // Determine label property
+    let labels = [];
+    let effectiveLabelPropertyId = labelPropertyId;
+
+    if (effectiveLabelPropertyId) {
+      const labelProperty = board.cardProperties?.find((p) => p.id === effectiveLabelPropertyId);
+      if (labelProperty?.options) {
+        labels = labelProperty.options;
+      }
+    }
+
+    // Determine custom fields to import
+    let customFieldProperties = [];
+    if (customFieldPropertyIds && customFieldPropertyIds.length > 0) {
+      customFieldProperties = board.cardProperties?.filter(
+        (p) => customFieldPropertyIds.includes(p.id)
+      ) || [];
+    }
+
+    console.log('');
+    console.log('--- Import Configuration ---');
+    console.log(`Column property: ${columnProperty.name} (${columnProperty.id})`);
+    console.log(`Label property: ${effectiveLabelPropertyId ? 'Yes' : 'None'}`);
+    console.log(`Due date property: ${dueDatePropertyId ? 'Yes' : 'None'}`);
+    console.log(`Custom fields: ${customFieldProperties.length}`);
+
+    return {
+      board,
+      views,
+      cards,
+      textBlocks,
+      // Mapping configuration
+      columnProperty,
+      labels,
+      labelPropertyId: effectiveLabelPropertyId,
+      dueDatePropertyId,
+      customFieldProperties,
+    };
+  },
+};
diff --git a/server/api/models/Board.js b/server/api/models/Board.js
index 3ff9ca4be..41df98425 100755
--- a/server/api/models/Board.js
+++ b/server/api/models/Board.js
@@ -96,6 +96,7 @@ const Views = {
 
 const ImportTypes = {
   TRELLO: 'trello',
+  FOCALBOARD: 'focalboard',
 };
 
 module.exports = {
diff --git a/server/config/routes.js b/server/config/routes.js
index 0392166e1..06d0869a6 100644
--- a/server/config/routes.js
+++ b/server/config/routes.js
@@ -195,6 +195,8 @@ module.exports.routes = {
   'POST /api/notification-services/:id/test': 'notification-services/test',
   'DELETE /api/notification-services/:id': 'notification-services/delete',
 
+  'POST /api/focalboard/preview': 'focalboard/preview',
+
   'GET /preloaded-favicons/*': {
     fn: staticDirServer('/preloaded-favicons', () =>
       path.join(