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..eefb7bdac
--- /dev/null
+++ b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx
@@ -0,0 +1,430 @@
+/*!
+ * 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';
+
+// Supported custom field types (stored as strings in Planka)
+const SUPPORTED_CUSTOM_FIELD_TYPES = ['text', 'url', 'number', 'email', 'phone', 'checkbox'];
+
+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 [assigneePropertyId, setAssigneePropertyId] = useState(null);
+  const [customFieldPropertyIds, setCustomFieldPropertyIds] = useState([]);
+  const [includeFocalboardUrl, setIncludeFocalboardUrl] = useState(true);
+  const [focalboardBaseUrl, setFocalboardBaseUrl] = 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.columns.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.labels.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.dates.map((p) => ({
+          key: p.id,
+          value: p.id,
+          text: p.name,
+        })),
+    ];
+  }, [previewData, t]);
+
+  const assigneeOptions = useMemo(() => {
+    if (!previewData) return [];
+    return [
+      { key: 'none', value: '', text: t('common.none') },
+      ...previewData.properties.assignees.map((p) => ({
+          key: p.id,
+          value: p.id,
+          text: `${p.name} (${p.type})`,
+        })),
+    ];
+  }, [previewData, t]);
+
+  // Get all custom field properties (excluding those used for columns/labels)
+  const customFieldProperties = useMemo(() => {
+    if (!previewData) return [];
+    return previewData.properties.customFields;
+
+  }, [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 handleAssigneeChange = useCallback((_, { value }) => {
+    setAssigneePropertyId(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 handleIncludeFocalboardUrlChange = useCallback(() => {
+    setIncludeFocalboardUrl((prev) => !prev);
+  }, []);
+
+  const handleFocalboardBaseUrlChange = useCallback((e) => {
+    setFocalboardBaseUrl(e.target.value);
+  }, []);
+
+  const handleSubmit = useCallback(() => {
+    console.log('DEBUG');
+    console.log(focalboardBaseUrl);
+    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,
+        assigneePropertyId: assigneePropertyId || undefined,
+        customFieldPropertyIds: customFieldPropertyIds.length > 0 ? customFieldPropertyIds : undefined,
+        includeFocalboardUrl,
+        focalboardBaseUrl: includeFocalboardUrl ? focalboardBaseUrl : undefined,
+      },
+    });
+  }, [
+    file,
+    useBoardTitle,
+    previewData,
+    columnPropertyId,
+    labelPropertyId,
+    dueDatePropertyId,
+    assigneePropertyId,
+    customFieldPropertyIds,
+    includeFocalboardUrl,
+    focalboardBaseUrl,
+    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 })}
+            {previewData.stats.totalComments > 0 && (
+              <> · {t('common.commentsCount', { count: previewData.stats.totalComments })}</>
+            )}
+            {previewData.stats.totalCheckboxes > 0 && (
+              <> · {t('common.tasksCount', { count: previewData.stats.totalCheckboxes })}</>
+            )}
+          </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>
+
+          {/* Assignees (optional) */}
+          {assigneeOptions.length > 1 && (
+            <div className={styles.section}>
+              <div className={styles.label}>{t('common.assignees')}</div>
+              <Dropdown
+                fluid
+                selection
+                options={assigneeOptions}
+                value={assigneePropertyId || ''}
+                placeholder={t('common.selectProperty')}
+                onChange={handleAssigneeChange}
+              />
+            </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 className={styles.checkboxItem}>
+                <Checkbox
+                  checked={includeFocalboardUrl}
+                  label={<label className={styles.checkboxLabel}>Add focalboard card URL</label>}
+                  onChange={handleIncludeFocalboardUrlChange}
+                />
+              </div>
+              {includeFocalboardUrl && (
+                <>
+                  <div className={styles.label}>
+                    {t('common.baseUrl')} <span className={styles.required}>*</span>
+                  </div><input
+                      className={styles.urlInput}
+                      type="text"
+                      value={focalboardBaseUrl}
+                      onChange={handleFocalboardBaseUrlChange} />
+                </>
+              )}
+              </div>
+            </div>
+          )}
+
+          <Button
+            positive
+            fluid
+            content={t('action.import')}
+            disabled={!columnPropertyId  || (includeFocalboardUrl && !focalboardBaseUrl.trim())}
+            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..8bd107d3c
--- /dev/null
+++ b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss
@@ -0,0 +1,164 @@
+/*!
+ * 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;
+    }
+  }
+
+  .urlInput {
+    width: 100%;
+    margin-top: 4px;
+    padding: 6px 8px;
+    border: 1px solid rgba(0, 0, 0, 0.15);
+    border-radius: 4px;
+    font-size: 13px;
+  }
+
+  .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..4d32a12fa 100644
--- a/client/src/locales/en-US/core.js
+++ b/client/src/locales/en-US/core.js
@@ -83,6 +83,7 @@ export default {
       areYouSureYouWantToRemoveThisMemberFromBoard:
         'Are you sure you want to remove this member from the board?',
       assignAsOwner_title: 'Assign As Owner',
+      assignees: "Assignees",
       atLeastOneListMustBePresent: 'At least one list must be present',
       attachment: 'Attachment',
       attachments: 'Attachments',
@@ -90,6 +91,7 @@ export default {
       background: 'Background',
       baseCustomFields_title: 'Base Custom Fields',
       baseGroup: 'Base group',
+      baseUrl: 'Base URL',
       board: 'Board',
       boardActions_title: 'Board Actions',
       boardNotFound_title: 'Board Not Found',
@@ -109,6 +111,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,7 +122,10 @@ export default {
       clientHostnameInEhlo: 'Client hostname in EHLO',
       closed: 'Closed',
       color: 'Color',
+      columns: 'Columns',
       comments: 'Comments',
+      commentsCount: "{{count}} comment",
+      commentsCount_plural: "{{count}} comments",
       contentExceedsLimit: 'Content exceeds {{limit}}',
       contentOfThisAttachmentIsTooBigToDisplay: 'Content of this attachment is too big to display.',
       copy_inline: 'copy',
@@ -192,13 +199,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 +250,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 +266,7 @@ export default {
       optional_inline: 'optional',
       organization: 'Organization',
       others: 'Others',
+      parsingFile: "Parsing file...",
       passwordIsSet: 'Password is set',
       phone: 'Phone',
       plankaUsesAppriseToSendNotificationsToOver100PopularServices:
@@ -290,6 +302,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.',
@@ -309,6 +322,8 @@ export default {
       taskAssignmentAndProjectCompletion: 'Task assignment and project completion.',
       taskListActions_title: 'Task List Actions',
       taskList_title: 'Task List',
+      tasksCount: "{{count}} task",
+      tasksCount_plural: "{{count}} tasks",
       team: 'Team',
       terms: 'Terms',
       testLog_title: 'Test Log',
@@ -322,6 +337,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 +403,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 +445,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 +491,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..0b02f49fa 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":"...","assigneePropertyId":"...","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,35 @@ 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.focalboard
+          .processUploadedImportFile.with({
+            file,
+            columnPropertyId: mapping.columnPropertyId,
+            labelPropertyId: mapping.labelPropertyId,
+            dueDatePropertyId: mapping.dueDatePropertyId,
+            assigneePropertyId: mapping.assigneePropertyId,
+            customFieldPropertyIds: mapping.customFieldPropertyIds || [],
+            includeFocalboardUrl: mapping.includeFocalboardUrl || false,
+            focalboardBaseUrl: mapping.focalboardBaseUrl,
+          })
+          .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..2acf4e9f2
--- /dev/null
+++ b/server/api/controllers/focalboard/preview.js
@@ -0,0 +1,250 @@
+/*!
+ * 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
+ *                     totalComments:
+ *                       type: number
+ *                     totalCheckboxes:
+ *                       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.focalboard.parseFile.with({
+        file,
+        previewOnly: true,
+      });
+    } catch (error) {
+      if (error === 'invalidFile' || error.code === 'invalidFile') {
+        throw Errors.INVALID_FILE;
+      }
+      throw error;
+    }
+
+    const { board, views, cardCount, textBlockCount, commentCount, checkboxCount } = focalboardData;
+
+    // Categorize properties for frontend dropdowns
+    const properties = {
+      columns: [],
+      labels: [],
+      dates: [],
+      assignees: [],
+      customFields: [],
+    };
+
+    for (const prop of board.cardProperties || []) {
+      const normalized = {
+        id: prop.id,
+        name: prop.name,
+        type: prop.type,
+        options: prop.options || [],
+      };
+
+      switch (prop.type) {
+        case 'select':
+          properties.columns.push(normalized);
+          break;
+        case 'multiSelect':
+          properties.labels.push(normalized);
+          break;
+        case 'date':
+          properties.dates.push(normalized);
+          break;
+        case 'person':
+        case 'multiPerson':
+          properties.assignees.push(normalized);
+          break;
+        case 'text':
+        case 'url':
+        case 'number':
+        case 'email':
+        case 'phone':
+        case 'checkbox':
+          properties.customFields.push(normalized);
+          break;
+        default:
+          // Skip: createdTime, createdBy, updatedTime, updatedBy, file, unknown
+          break;
+      }
+    }
+
+    // Suggest column property from the kanban view
+    const kanbanView = views.find((v) => v.fields?.viewType === 'board');
+    const suggestedColumnPropertyId = kanbanView?.fields?.groupById || null;
+
+    // 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,
+      suggestedColumnPropertyId,
+      views: viewsInfo,
+      stats: {
+        totalCards: cardCount,
+        totalTextBlocks: textBlockCount,
+        totalComments: commentCount,
+        totalCheckboxes: checkboxCount,
+      },
+    });
+  },
+};
diff --git a/server/api/helpers/boards/create-one.js b/server/api/helpers/boards/create-one.js
index a09a7252d..5cf26c826 100644
--- a/server/api/helpers/boards/create-one.js
+++ b/server/api/helpers/boards/create-one.js
@@ -88,6 +88,15 @@ module.exports = {
       await sails.helpers.boards.importFromTrello(board, lists, inputs.import.board);
     }
 
+    if (inputs.import && inputs.import.type === Board.ImportTypes.FOCALBOARD) {
+      await sails.helpers.focalboard.importBoard.with({
+        board,
+        lists,
+        focalboardData: inputs.import.data,
+        actorUser: inputs.actorUser,
+      });
+    }
+
     scoper.board = board;
     scoper.boardMemberships = [boardMembership];
 
diff --git a/server/api/helpers/focalboard/build-user-mapping.js b/server/api/helpers/focalboard/build-user-mapping.js
new file mode 100644
index 000000000..fc52f5799
--- /dev/null
+++ b/server/api/helpers/focalboard/build-user-mapping.js
@@ -0,0 +1,135 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @description :: Maps Focalboard users to Planka users by username/email.
+ *                 Returns mapping and stats.
+ */
+
+module.exports = {
+  inputs: {
+    focalboardUsers: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard user objects from export',
+    },
+  },
+
+  exits: {
+    success: {
+      description: 'User mapping created successfully',
+    },
+  },
+
+  async fn(inputs) {
+    const { focalboardUsers } = inputs;
+
+    const mapping = {
+      focalboardUserIdToPlankaUserId: {},
+      unmatchedUsers: [],
+      duplicateWarnings: [],
+      stats: {
+        total: focalboardUsers.length,
+        matchedByUsername: 0,
+        matchedByEmail: 0,
+        unmatched: 0,
+        duplicates: 0,
+      },
+    };
+
+    console.log('');
+    console.log('=== Building User Mapping ===');
+    console.log(`Total Focalboard users: ${focalboardUsers.length}`);
+
+    for (const fbUser of focalboardUsers) {
+      const { userId, username, email, firstname, lastname } = fbUser;
+
+      let plankaUser = null;
+      let matchMethod = null;
+
+      // Try matching by username first
+      if (username) {
+        const usersByUsername = await User.find({ username });
+
+        if (usersByUsername.length === 1) {
+          plankaUser = usersByUsername[0];
+          matchMethod = 'username';
+          mapping.stats.matchedByUsername++;
+        } else if (usersByUsername.length > 1) {
+          // Multiple users with same username - try to disambiguate by email
+          if (email) {
+            const exactMatch = usersByUsername.find(u => u.email === email);
+            if (exactMatch) {
+              plankaUser = exactMatch;
+              matchMethod = 'username+email';
+              mapping.stats.matchedByUsername++;
+
+              console.warn(
+                `⚠️  Multiple users with username "${username}", matched by email: ${email}`
+              );
+              mapping.duplicateWarnings.push({
+                focalboardUserId: userId,
+                username,
+                email,
+                matchedPlankaUserId: exactMatch.id,
+              });
+              mapping.stats.duplicates++;
+            } else {
+              console.warn(
+                `⚠️  Multiple users with username "${username}", no email match. Skipping.`
+              );
+              mapping.stats.duplicates++;
+              mapping.stats.unmatched++;
+              mapping.unmatchedUsers.push(fbUser);
+              continue;
+            }
+          } else {
+            console.warn(
+              `⚠️  Multiple users with username "${username}", no email to disambiguate. Skipping.`
+            );
+            mapping.stats.duplicates++;
+            mapping.stats.unmatched++;
+            mapping.unmatchedUsers.push(fbUser);
+            continue;
+          }
+        }
+      }
+
+      // Fallback: try matching by email
+      if (!plankaUser && email) {
+        plankaUser = await User.findOne({ email });
+        if (plankaUser) {
+          matchMethod = 'email';
+          mapping.stats.matchedByEmail++;
+        }
+      }
+
+      // Store mapping or mark as unmatched
+      if (plankaUser) {
+        mapping.focalboardUserIdToPlankaUserId[userId] = plankaUser.id;
+
+        const displayName = firstname || lastname
+          ? `${firstname} ${lastname}`.trim()
+          : username || email;
+
+        // console.log(`✓ Matched: ${displayName} (${matchMethod}) → Planka user ${plankaUser.id}`);
+      } else {
+        mapping.stats.unmatched++;
+        mapping.unmatchedUsers.push(fbUser);
+      }
+    }
+
+    console.log('');
+    console.log('--- User Mapping Summary ---');
+    console.log(`Total users: ${mapping.stats.total}`);
+    console.log(`  Matched by username: ${mapping.stats.matchedByUsername}`);
+    console.log(`  Matched by email: ${mapping.stats.matchedByEmail}`);
+    console.log(`  Unmatched (skipped): ${mapping.stats.unmatched}`);
+    console.log(`  Duplicate username warnings: ${mapping.stats.duplicates}`);
+    console.log('');
+
+    return mapping;
+  },
+};
diff --git a/server/api/helpers/focalboard/convert-label-color.js b/server/api/helpers/focalboard/convert-label-color.js
new file mode 100644
index 000000000..0660d60e2
--- /dev/null
+++ b/server/api/helpers/focalboard/convert-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/focalboard/group-cards-by-list.js b/server/api/helpers/focalboard/group-cards-by-list.js
new file mode 100644
index 000000000..85a703a61
--- /dev/null
+++ b/server/api/helpers/focalboard/group-cards-by-list.js
@@ -0,0 +1,131 @@
+/*!
+ * 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}`);
+
+    return cardsByListId;
+  },
+};
diff --git a/server/api/helpers/focalboard/import-board-members.js b/server/api/helpers/focalboard/import-board-members.js
new file mode 100644
index 000000000..af3f017bf
--- /dev/null
+++ b/server/api/helpers/focalboard/import-board-members.js
@@ -0,0 +1,102 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @description :: Imports Focalboard board members as Planka BoardMembership records.
+ */
+
+module.exports = {
+  inputs: {
+    boardId: {
+      type: 'string',
+      required: true,
+    },
+    projectId: {
+      type: 'string',
+      required: true,
+    },
+    focalboardBoardMembers: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard boardMember objects',
+    },
+    userMapping: {
+      type: 'ref',
+      required: true,
+      description: 'Mapping from Focalboard user IDs to Planka user IDs',
+    },
+    focalboardUsers: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard user objects (for username lookup)',
+    },
+  },
+
+  async fn(inputs) {
+    const { boardId, projectId, focalboardBoardMembers, userMapping, focalboardUsers } = inputs;
+
+    // Build userId → username lookup
+    const usernameByUserId = {};
+    focalboardUsers.forEach((u) => {
+      usernameByUserId[u.userId] = u.username || u.email || u.userId;
+    });
+
+    console.log('');
+    console.log('=== Importing Board Members ===');
+    console.log(`Total board members: ${focalboardBoardMembers.length}`);
+
+    const stats = {
+      created: 0,
+      skipped: 0,
+    };
+    const skippedUsers = [];
+
+    for (const fbMember of focalboardBoardMembers) {
+      const { userId, schemeAdmin, schemeEditor, schemeViewer, schemeCommenter } = fbMember;
+
+      const plankaUserId = userMapping[userId];
+
+      if (!plankaUserId) {
+        stats.skipped++;
+        skippedUsers.push(usernameByUserId[userId] || userId);
+        continue;
+      }
+
+      // Skip members with no rights in Focalboard
+      const hasRights = schemeAdmin || schemeEditor || schemeViewer || schemeCommenter;
+      if (!hasRights) {
+        stats.skipped++;
+        skippedUsers.push(usernameByUserId[userId] || userId);
+        continue;
+      }
+
+      try {
+        await BoardMembership.create({
+          boardId,
+          projectId,
+          userId: plankaUserId,
+          role: 'editor',
+          canComment: null,
+        }).fetch();
+
+        stats.created++;
+      } catch (error) {
+        stats.skipped++;
+        skippedUsers.push(usernameByUserId[userId] || userId);
+      }
+    }
+
+    console.log('');
+    console.log('--- Board Members Summary ---');
+    console.log(`Created: ${stats.created}`);
+    console.log(`Skipped: ${stats.skipped}`);
+    if (skippedUsers.length > 0) {
+      console.log(`Skipped users: ${skippedUsers.join(', ')}`);
+    }
+    console.log('');
+
+    return stats;
+  },
+};
diff --git a/server/api/helpers/focalboard/import-board.js b/server/api/helpers/focalboard/import-board.js
new file mode 100644
index 000000000..626871224
--- /dev/null
+++ b/server/api/helpers/focalboard/import-board.js
@@ -0,0 +1,226 @@
+/*!
+ * 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,
+    },
+    actorUser: {
+      type: 'ref',
+      required: true,
+      description: 'The user who triggered the import (used as fallback action creator)',
+    },
+  },
+
+  async fn(inputs) {
+    const {
+      board: boardBlock,
+      views,
+      cards: focalboardCards,
+      textBlocks,
+      comments,
+      checkboxes,
+      boardMembers,
+      users,
+      columnProperty,
+      labels: focalboardLabels,
+      labelPropertyId,
+      dueDatePropertyId,
+      assigneePropertyId,
+      customFieldProperties,
+      includeFocalboardUrl,
+      focalboardBaseUrl,
+    } = 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');
+    }
+
+    console.log(`Include Focalboard URL: ${includeFocalboardUrl}`);
+    console.log(`Focalboard base URL: ${focalboardBaseUrl}`);
+
+    // =====================================================
+    // BUILD USER MAPPING
+    // =====================================================
+    const userMappingResult = await sails.helpers.focalboard.buildUserMapping(users);
+    const userMapping = userMappingResult.focalboardUserIdToPlankaUserId;
+
+    // =====================================================
+    // IMPORT BOARD MEMBERS
+    // =====================================================
+
+    await sails.helpers.focalboard.importBoardMembers(
+      inputs.board.id,
+      inputs.board.projectId,
+      boardMembers,
+      userMapping,
+      users,
+    );
+
+    // =====================================================
+    // IMPORT LABELS
+    // =====================================================
+
+    const labelIdByFocalboardLabelId = await sails.helpers.focalboard.importLabels(
+      inputs.board.id,
+      focalboardLabels || [],
+    );
+
+    // =====================================================
+    // LISTS SECTION
+    // =====================================================
+    const { listIdByOptionId, listById, unorderedList } =
+      await sails.helpers.focalboard.importLists(
+        inputs.board.id,
+        kanbanView.fields?.visibleOptionIds || [],
+        columnProperty.options,
+      );
+
+    // =====================================================
+    // GROUP CARDS BY LIST
+    // =====================================================
+
+    const columnPropertyId = columnProperty.id;
+
+    const cardsByListId = sails.helpers.focalboard.groupCardsByList(
+      focalboardCards,
+      kanbanView.fields.cardOrder || [],
+      columnPropertyId,
+      listIdByOptionId,
+      unorderedList.id,
+      unorderedList.name,
+      columnProperty.options,
+    );
+
+    // =====================================================
+    // IMPORT CUSTOM FIELDS
+    // =====================================================
+
+    let customFieldGroup = null;
+    let customFieldIdByFocalboardPropertyId = {};
+    let focalboardUrlFieldId = null;
+
+    if ((customFieldProperties && customFieldProperties.length > 0) || includeFocalboardUrl) {
+      const result = await sails.helpers.focalboard.importCustomFields(
+        inputs.board.id,
+        customFieldProperties || [],
+        includeFocalboardUrl,
+      );
+      customFieldGroup = result.customFieldGroup;
+      customFieldIdByFocalboardPropertyId = result.customFieldIdByFocalboardPropertyId;
+      focalboardUrlFieldId = result.focalboardUrlFieldId;
+    }
+
+    // =====================================================
+    // IMPORT CARDS
+    // =====================================================
+
+    const { stats, cardIdMapping } = await sails.helpers.focalboard.importCards(
+      inputs.board.id,
+      cardsByListId,
+      textBlocks,
+      dueDatePropertyId,
+      labelPropertyId,
+      labelIdByFocalboardLabelId,
+      listById,
+      assigneePropertyId,
+      userMapping,
+      inputs.actorUser,
+      customFieldGroup,
+      customFieldIdByFocalboardPropertyId,
+      focalboardUrlFieldId,
+      kanbanView.id,
+      focalboardBaseUrl,
+    );
+
+    // =====================================================
+    // IMPORT COMMENTS
+    // =====================================================
+
+    const commentStats = await sails.helpers.focalboard.importComments(
+      comments || [],
+      cardIdMapping,
+      userMapping,
+      users,
+    );
+
+    // =====================================================
+    // IMPORT CHECKBOXES (as TaskLists/Tasks)
+    // =====================================================
+
+    const checkboxStats = await sails.helpers.focalboard.importCheckboxes(
+      checkboxes || [],
+      cardIdMapping,
+    );
+
+    // =====================================================
+    // 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(`Cards with Focalboard URL: ${stats.cardsWithFocalboardUrl}`);
+    console.log(`Cards with creator: ${stats.cardsWithCreator}`);
+    console.log(`Cards with members: ${stats.cardsWithMembers}`);
+    console.log(`Card memberships created: ${stats.cardMembershipsCreated}`);
+    console.log(`Labels created: ${Object.keys(labelIdByFocalboardLabelId).length}`);
+    console.log(`Lists created: ${Object.keys(listIdByOptionId).length + 1} (including "${unorderedList.name}")`);
+    console.log(`Custom fields created: ${Object.keys(customFieldIdByFocalboardPropertyId).length}`);
+    console.log(`Comments imported: ${commentStats.totalCommentsImported}`);
+    console.log(`Comments with matched user: ${commentStats.commentsWithUser}`);
+    console.log(`Comments without matched user: ${commentStats.commentsWithoutUser}`);
+    console.log(`TaskLists created: ${checkboxStats.totalTaskListsCreated}`);
+    console.log(`Tasks created: ${checkboxStats.totalTasksCreated}`);
+    console.log('');
+  },
+};
diff --git a/server/api/helpers/focalboard/import-cards.js b/server/api/helpers/focalboard/import-cards.js
new file mode 100644
index 000000000..2e1ec8f8d
--- /dev/null
+++ b/server/api/helpers/focalboard/import-cards.js
@@ -0,0 +1,334 @@
+/*!
+ * 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, custom field values,
+ *                 and CREATE_CARD action records with original Focalboard timestamps.
+ */
+
+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',
+    },
+    listById: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Planka list ID to full list object',
+    },
+    assigneePropertyId: {
+      type: 'string',
+      allowNull: true,
+      description: 'Focalboard property ID for assignees (maps to CardMembership)',
+    },
+    userMapping: {
+      type: 'ref',
+      description: 'Map of Focalboard user ID to Planka user ID',
+    },
+    actorUser: {
+      type: 'ref',
+      required: true,
+      description: 'The user who triggered the import (fallback for action userId)',
+    },
+    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',
+    },
+    focalboardUrlFieldId: {
+      type: 'ref',
+      description: 'Planka custom field ID for the Focalboard URL field (null if not requested)',
+    },
+    focalboardViewId: {
+      type: 'string',
+      description: 'Focalboard view ID used to construct card URLs',
+    },
+    focalboardBaseUrl: {
+      type: 'string',
+      description: 'Base URL of the Focalboard instance',
+    },
+  },
+
+  async fn(inputs) {
+    const {
+      boardId,
+      cardsByListId,
+      textBlocks,
+      dueDatePropertyId,
+      labelPropertyId,
+      labelIdByFocalboardLabelId,
+      listById,
+      assigneePropertyId,
+      userMapping,
+      actorUser,
+      customFieldGroup,
+      customFieldIdByFocalboardPropertyId,
+      focalboardUrlFieldId,
+      focalboardViewId,
+      focalboardBaseUrl,
+    } = inputs;
+
+    console.log('');
+    console.log('--- Importing Cards ---');
+
+    console.log(`Focalboard URL field ID: ${focalboardUrlFieldId}`);
+    console.log(`Focalboard view ID: ${focalboardViewId}`);
+    console.log(`Focalboard base URL: ${focalboardBaseUrl}`);
+
+    // 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,
+      cardsWithMembers: 0,
+      cardsWithCreator: 0,
+      cardMembershipsCreated: 0,
+      cardsWithCustomFields: 0,
+      customFieldValuesCreated: 0,
+      cardsWithFocalboardUrl: 0,
+    };
+
+    // Mapping of Focalboard card ID to Planka card ID (for comments import)
+    const cardIdMapping = {};
+
+    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;
+
+      const list = listById[listId];
+      const listName = list?.name || 'Unknown';
+
+      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.focalboard.parseDate(dueDateRaw);
+
+            if (dueDate) {
+              stats.cardsWithDueDate += 1;
+            }
+          }
+
+          const creatorPlankaId = userMapping[focalboardCard.createdBy];
+
+          // 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().toISOString(),
+            creatorUserId: creatorPlankaId || null,
+            createdAt: focalboardCard.createAt
+              ? new Date(focalboardCard.createAt).toISOString()
+              : undefined,
+          };
+
+          if (!focalboardCard.title?.trim()) {
+            stats.cardsWithoutTitle += 1;
+          }
+
+          const card = await Card.qm.createOne(cardValues);
+
+          // Store mapping for comments import
+          cardIdMapping[focalboardCard.id] = card.id;
+
+          if (creatorPlankaId) {
+            stats.cardsWithCreator++;
+          }
+
+          stats.totalCardsImported += 1;
+
+          // Create CREATE_CARD action with original Focalboard timestamp.
+          // We bypass sails.helpers.actions.createOne to avoid triggering
+          // webhooks, sockets, and notifications during bulk import.
+          // userId falls back to actorUser (the importer) if the original
+          // Focalboard creator has no matching Planka account.
+          await Action.qm.createOne({
+            boardId,
+            cardId: card.id,
+            userId: creatorPlankaId || actorUser.id,
+            type: Action.Types.CREATE_CARD,
+            data: {
+              card: { name: card.name },
+              list: { id: list.id, type: list.type, name: list.name },
+            },
+            createdAt: card.createdAt,
+          });
+
+          // Assign card members from assignee property
+          if (assigneePropertyId && userMapping) {
+            const assigneeValue = focalboardCard.fields?.properties?.[assigneePropertyId];
+
+            if (assigneeValue) {
+              const userIds = Array.isArray(assigneeValue) ? assigneeValue : [assigneeValue];
+              let hasMembers = false;
+
+              await Promise.all(
+                userIds.map(async (fbUserId) => {
+                  if (!fbUserId) return;
+
+                  const plankaUserId = userMapping[fbUserId];
+
+                  if (plankaUserId) {
+                    await CardMembership.qm.createOne({
+                      cardId: card.id,
+                      userId: plankaUserId,
+                    });
+                    hasMembers = true;
+                    stats.cardMembershipsCreated += 1;
+                  }
+                }),
+              );
+
+              if (hasMembers) {
+                stats.cardsWithMembers += 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: card.id,
+                      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: card.id,
+                    customFieldGroupId: customFieldGroup.id,
+                    customFieldId: plankaCustomFieldId,
+                    content,
+                  });
+
+                  stats.customFieldValuesCreated += 1;
+                  cardHasCustomFields = true;
+                },
+              ),
+            );
+
+            if (cardHasCustomFields) {
+              stats.cardsWithCustomFields += 1;
+            }
+          }
+
+          // Create Focalboard URL custom field value
+          if (focalboardUrlFieldId && focalboardBaseUrl && focalboardViewId) {
+            const url = `${focalboardBaseUrl}/${focalboardCard.boardId}/${focalboardViewId}/${focalboardCard.id}`;
+
+            await CustomFieldValue.qm.createOrUpdateOne({
+              cardId: card.id,
+              customFieldGroupId: customFieldGroup.id,
+              customFieldId: focalboardUrlFieldId,
+              content: url,
+            });
+
+            stats.cardsWithFocalboardUrl += 1;
+          }
+        }),
+      );
+
+      //console.log(`Created ${cards.length} cards in list "${listName}"`);
+    }
+
+    return { stats, cardIdMapping };
+  },
+};
diff --git a/server/api/helpers/focalboard/import-checkboxes.js b/server/api/helpers/focalboard/import-checkboxes.js
new file mode 100644
index 000000000..f568b373a
--- /dev/null
+++ b/server/api/helpers/focalboard/import-checkboxes.js
@@ -0,0 +1,110 @@
+/*!
+ * 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 :: Imports Focalboard checkboxes as Planka TaskLists and Tasks.
+ *                 Creates one TaskList named "Checklist" per card, containing all checkboxes as Tasks.
+ */
+
+module.exports = {
+  inputs: {
+    checkboxes: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard checkbox blocks',
+    },
+    cardIdMapping: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Focalboard card ID to Planka card ID',
+    },
+  },
+
+  async fn(inputs) {
+    const { checkboxes, cardIdMapping } = inputs;
+
+    console.log('');
+    console.log('=== Importing Checkboxes ===');
+    console.log(`Total checkboxes to import: ${checkboxes.length}`);
+
+    const stats = {
+      totalTaskListsCreated: 0,
+      totalTasksCreated: 0,
+      skippedNoCard: 0,
+      skippedNoTitle: 0,
+    };
+
+    if (checkboxes.length === 0) {
+      console.log('No checkboxes to import');
+      return stats;
+    }
+
+    // Group checkboxes by card (parentId)
+    const checkboxesByCardId = {};
+    for (const checkbox of checkboxes) {
+      const focalboardCardId = checkbox.parentId;
+      if (!checkboxesByCardId[focalboardCardId]) {
+        checkboxesByCardId[focalboardCardId] = [];
+      }
+      checkboxesByCardId[focalboardCardId].push(checkbox);
+    }
+
+    console.log(`Cards with checkboxes: ${Object.keys(checkboxesByCardId).length}`);
+
+    // Process checkboxes for each card
+    for (const [focalboardCardId, cardCheckboxes] of Object.entries(checkboxesByCardId)) {
+      const plankaCardId = cardIdMapping[focalboardCardId];
+
+      if (!plankaCardId) {
+        // Card wasn't imported (might have been filtered out)
+        stats.skippedNoCard += cardCheckboxes.length;
+        continue;
+      }
+
+      // Create TaskList for this card
+      const taskList = await TaskList.qm.createOne({
+        cardId: plankaCardId,
+        position: POSITION_GAP,
+        name: 'Checklist',
+      });
+
+      stats.totalTaskListsCreated += 1;
+
+      // Create Tasks from checkboxes (preserving order from export file)
+      for (let index = 0; index < cardCheckboxes.length; index++) {
+        const checkbox = cardCheckboxes[index];
+        const taskName = checkbox.title?.trim();
+
+        if (!taskName) {
+          stats.skippedNoTitle += 1;
+          continue;
+        }
+
+        const isCompleted = checkbox.fields?.value === true;
+
+        await Task.qm.createOne({
+          taskListId: taskList.id,
+          position: POSITION_GAP * (index + 1),
+          name: taskName,
+          isCompleted,
+        });
+
+        stats.totalTasksCreated += 1;
+      }
+    }
+
+    console.log('');
+    console.log('--- Checkboxes Import Summary ---');
+    console.log(`TaskLists created: ${stats.totalTaskListsCreated}`);
+    console.log(`Tasks created: ${stats.totalTasksCreated}`);
+    console.log(`Skipped (card not found): ${stats.skippedNoCard}`);
+    console.log(`Skipped (empty title): ${stats.skippedNoTitle}`);
+    console.log('');
+
+    return stats;
+  },
+};
diff --git a/server/api/helpers/focalboard/import-comments.js b/server/api/helpers/focalboard/import-comments.js
new file mode 100644
index 000000000..ba975f856
--- /dev/null
+++ b/server/api/helpers/focalboard/import-comments.js
@@ -0,0 +1,145 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @description :: Imports Focalboard comments as Planka Comment records.
+ *                 Handles user attribution with fallback to "[Originally by: username]" prefix.
+ */
+
+module.exports = {
+  inputs: {
+    comments: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard comment blocks',
+    },
+    cardIdMapping: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Focalboard card ID to Planka card ID',
+    },
+    userMapping: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Focalboard user ID to Planka user ID',
+    },
+    focalboardUsers: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard user objects (for usernames)',
+    },
+  },
+
+  async fn(inputs) {
+    const { comments, cardIdMapping, userMapping, focalboardUsers } = inputs;
+
+    console.log('');
+    console.log('=== Importing Comments ===');
+
+    const stats = {
+      totalCommentsImported: 0,
+      commentsWithUser: 0,
+      commentsWithoutUser: 0,
+      skippedNoCard: 0,
+      skippedNoText: 0,
+      cardsWithCommentsUpdated: 0,
+    };
+
+    if (comments.length === 0) {
+      console.log('No comments to import');
+      return stats;
+    }
+
+    // Build lookup: focalboardUserId → username
+    const usernames = {};
+    for (const user of focalboardUsers) {
+      usernames[user.userId] = user.username || user.email || user.userId;
+    }
+
+    // Group comments by card (parentId)
+    const commentsByCardId = {};
+    for (const comment of comments) {
+      const focalboardCardId = comment.parentId;
+      if (!commentsByCardId[focalboardCardId]) {
+        commentsByCardId[focalboardCardId] = [];
+      }
+      commentsByCardId[focalboardCardId].push(comment);
+    }
+
+    // Process comments for each card
+    for (const [focalboardCardId, cardComments] of Object.entries(commentsByCardId)) {
+      const plankaCardId = cardIdMapping[focalboardCardId];
+
+      if (!plankaCardId) {
+        // Card wasn't imported (might have been filtered out)
+        stats.skippedNoCard += cardComments.length;
+        continue;
+      }
+
+      let commentsCreatedForCard = 0;
+
+      for (const fbComment of cardComments) {
+        // Comment text is in the 'title' field
+        const originalText = fbComment.title?.trim();
+
+        if (!originalText) {
+          stats.skippedNoText += 1;
+          continue;
+        }
+
+        // Find Planka user
+        const plankaUserId = userMapping[fbComment.createdBy];
+
+        let commentText = originalText;
+
+        if (!plankaUserId && fbComment.createdBy) {
+          // User not found in Planka - add attribution prefix
+          const username = usernames[fbComment.createdBy] || fbComment.createdBy;
+          commentText = `[Originally by: ${username}]\n\n${originalText}`;
+          stats.commentsWithoutUser += 1;
+        } else if (plankaUserId) {
+          stats.commentsWithUser += 1;
+        } else {
+          // No createdBy at all
+          stats.commentsWithoutUser += 1;
+        }
+
+        // Create comment
+        await Comment.qm.createOne({
+          cardId: plankaCardId,
+          userId: plankaUserId || null,
+          text: commentText,
+          createdAt: fbComment.createAt
+            ? new Date(fbComment.createAt).toISOString()
+            : undefined,
+        });
+
+        stats.totalCommentsImported += 1;
+        commentsCreatedForCard += 1;
+      }
+
+      // Update card's commentsTotal counter
+      if (commentsCreatedForCard > 0) {
+        await Card.qm.updateOne(
+          { id: plankaCardId },
+          { commentsTotal: commentsCreatedForCard },
+        );
+        stats.cardsWithCommentsUpdated += 1;
+      }
+    }
+
+    console.log('');
+    console.log('--- Comments Import Summary ---');
+    console.log(`Total comments imported: ${stats.totalCommentsImported}`);
+    console.log(`Comments with matched user: ${stats.commentsWithUser}`);
+    console.log(`Comments without matched user (attributed in text): ${stats.commentsWithoutUser}`);
+    console.log(`Skipped (card not found): ${stats.skippedNoCard}`);
+    console.log(`Skipped (empty text): ${stats.skippedNoText}`);
+    console.log(`Cards updated with comment count: ${stats.cardsWithCommentsUpdated}`);
+    console.log('');
+
+    return stats;
+  },
+};
diff --git a/server/api/helpers/focalboard/import-custom-fields.js b/server/api/helpers/focalboard/import-custom-fields.js
new file mode 100644
index 000000000..436b8f8df
--- /dev/null
+++ b/server/api/helpers/focalboard/import-custom-fields.js
@@ -0,0 +1,114 @@
+/*!
+ * 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.
+ *                 Optionally creates a "Focalboard URL" field for linking back to the source.
+ *                 Returns the group, field mapping, and URL field ID for use during card import.
+ */
+
+// Custom field group name in Planka
+const CUSTOM_FIELD_GROUP_NAME = 'Custom fields';
+const FOCALBOARD_URL_FIELD_NAME = 'Focalboard URL';
+
+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',
+    },
+    includeFocalboardUrl: {
+      type: 'boolean',
+      defaultsTo: false,
+      description: 'Whether to create a "Focalboard URL" custom field for linking back to the source card',
+    },
+  },
+
+  async fn(inputs) {
+    const { boardId, customFieldProperties, includeFocalboardUrl } = inputs;
+
+    console.log('');
+    console.log('--- Creating Custom Fields ---');
+
+    const hasCustomFields = customFieldProperties && customFieldProperties.length > 0;
+
+    if (!hasCustomFields && !includeFocalboardUrl) {
+      console.log('No custom fields to import');
+      return {
+        customFieldGroup: null,
+        customFieldIdByFocalboardPropertyId: {},
+        focalboardUrlFieldId: null,
+      };
+    }
+
+    if (hasCustomFields) {
+      console.log(`Custom fields to import: ${customFieldProperties.length}`);
+    }
+    if (includeFocalboardUrl) {
+      console.log('Will create Focalboard URL field');
+    }
+
+    // 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 = {};
+    let nextPosition = 1;
+
+    if (hasCustomFields) {
+      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})`);
+        }),
+      );
+
+      nextPosition = customFieldProperties.length + 1;
+    }
+
+    // Step 3: Create Focalboard URL field if requested
+    let focalboardUrlFieldId = null;
+
+    if (includeFocalboardUrl) {
+      const urlField = await CustomField.qm.createOne({
+        customFieldGroupId: customFieldGroup.id,
+        position: POSITION_GAP * nextPosition,
+        name: FOCALBOARD_URL_FIELD_NAME,
+      });
+
+      focalboardUrlFieldId = urlField.id;
+    }
+
+    const totalCreated = Object.keys(customFieldIdByFocalboardPropertyId).length
+      + (focalboardUrlFieldId ? 1 : 0);
+    console.log(`Total custom fields created: ${totalCreated}`);
+
+    return {
+      customFieldGroup,
+      customFieldIdByFocalboardPropertyId,
+      focalboardUrlFieldId,
+    };
+  },
+};
diff --git a/server/api/helpers/focalboard/import-labels.js b/server/api/helpers/focalboard/import-labels.js
new file mode 100644
index 000000000..c4f0db9e6
--- /dev/null
+++ b/server/api/helpers/focalboard/import-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.focalboard.convertLabelColor(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/focalboard/import-lists.js b/server/api/helpers/focalboard/import-lists.js
new file mode 100644
index 000000000..12006cb5a
--- /dev/null
+++ b/server/api/helpers/focalboard/import-lists.js
@@ -0,0 +1,87 @@
+/*!
+ * 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;
+
+    // If visibleOptionIds is empty, fall back to all column options (in their defined order)
+    const effectiveVisibleIds = (visibleOptionIds && visibleOptionIds.length > 0)
+      ? visibleOptionIds
+      : columnOptions.map(opt => opt.id);
+
+    console.log('');
+    console.log('--- Creating Lists ---');
+    console.log(`Visible columns: ${effectiveVisibleIds.length}${visibleOptionIds.length === 0 ? ' (fallback to all options)' : ''}`);
+
+    const listIdByOptionId = {};
+    const listById = {};
+
+    await Promise.all(
+      effectiveVisibleIds.map(async (optionId, index) => {
+        const option = columnOptions.find((opt) => opt.id === optionId);
+
+        if (!option) {
+          console.log(`  [${index}] Option not found: ${optionId}`);
+          return;
+        }
+
+        const list = await List.qm.createOne({
+          boardId,
+          type: List.Types.ACTIVE,
+          position: POSITION_GAP * (index + 1),
+          name: option.value,
+        });
+
+        listIdByOptionId[optionId] = list.id;
+        listById[list.id] = list;
+        // console.log(`  [${index}] Created list: "${option.value}"`);
+      }),
+    );
+
+    console.log(`  ✓ Created ${Object.keys(listIdByOptionId).length} lists`);
+
+    // Create an "Unordered" list for cards not in cardOrder or without column
+    const unorderedList = await List.qm.createOne({
+      boardId,
+      type: List.Types.ACTIVE,
+      position: POSITION_GAP * (effectiveVisibleIds.length + 1),
+      name: 'Unordered',
+    });
+
+    listById[unorderedList.id] = unorderedList;
+    console.log(`Created "Unordered" list (position: ${unorderedList.position})`);
+
+    return {
+      listIdByOptionId,
+      listById,
+      unorderedList,
+    };
+  },
+};
diff --git a/server/api/helpers/focalboard/parse-date.js b/server/api/helpers/focalboard/parse-date.js
new file mode 100644
index 000000000..d10ff9816
--- /dev/null
+++ b/server/api/helpers/focalboard/parse-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/focalboard/parse-file.js b/server/api/helpers/focalboard/parse-file.js
new file mode 100644
index 000000000..b11a5f688
--- /dev/null
+++ b/server/api/helpers/focalboard/parse-file.js
@@ -0,0 +1,190 @@
+/*!
+ * 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) {
+    const { previewOnly } = inputs;
+
+    if (previewOnly) {
+      console.log('');
+      console.log('=== Parsing Focalboard JSONL File (Preview) ===');
+    }
+
+    const fileStream = fs.createReadStream(inputs.file.fd);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity,
+    });
+
+    const data = {
+      board: null,
+      views: [],
+      cards: [],
+      textBlocks: [],
+      comments: [],
+      checkboxes: [],
+      boardMembers: [],
+      users: [],
+    };
+
+    let lineCount = 0;
+    let emptyLines = 0;
+    let parseErrors = 0;
+    let cardCount = 0;
+    let textBlockCount = 0;
+    let commentCount = 0;
+    let checkboxCount = 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';
+        }
+
+        if (!parsed.data) continue;
+
+        switch (parsed.type) {
+          case 'board':
+            data.board = parsed.data;
+            if (previewOnly) {
+              console.log(`Found board: "${parsed.data.title}"`);
+            }
+            continue;
+          case 'boardMember':
+            data.boardMembers.push(parsed.data);
+            continue;
+          case 'user':
+            data.users.push(parsed.data);
+            continue;
+          case 'block':
+            break; // fall through to block-type switch below
+          default:
+            continue;
+        }
+
+        // Handle block subtypes
+        switch (parsed.data.type) {
+          case 'view':
+            data.views.push(parsed.data);
+            break;
+          case 'card':
+            if (previewOnly) { cardCount++; } else { data.cards.push(parsed.data); }
+            break;
+          case 'text':
+            if (previewOnly) { textBlockCount++; } else { data.textBlocks.push(parsed.data); }
+            break;
+          case 'comment':
+            if (previewOnly) { commentCount++; } else { data.comments.push(parsed.data); }
+            break;
+          case 'checkbox':
+            if (previewOnly) { checkboxCount++; } else { data.checkboxes.push(parsed.data); }
+            break;
+          default:
+            unknownBlockTypes.add(parsed.data.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);
+
+    // 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, show summary and add counts to data
+    if (previewOnly) {
+      console.log('');
+      console.log('--- Parsing Summary ---');
+      console.log(`Total lines: ${lineCount}`);
+      console.log(`Empty lines: ${emptyLines}`);
+      console.log(`Board: ${data.board.title}`);
+      console.log(`Views: ${data.views.length}`);
+      console.log(`Cards: ${cardCount}`);
+      console.log(`Text blocks: ${textBlockCount}`);
+      console.log(`Comments: ${commentCount}`);
+      console.log(`Checkboxes: ${checkboxCount}`);
+      console.log(`Board members: ${data.boardMembers.length}`);
+      console.log(`Users: ${data.users.length}`);
+
+      if (unknownBlockTypes.size > 0) {
+        console.log(`Unknown block types (ignored): ${Array.from(unknownBlockTypes).join(', ')}`);
+      }
+
+      if (parseErrors > 0) {
+        console.warn(`Parse errors: ${parseErrors}`);
+      }
+
+      console.log('✓ File parsed successfully');
+      console.log('');
+
+      data.cardCount = cardCount;
+      data.textBlockCount = textBlockCount;
+      data.commentCount = commentCount;
+      data.checkboxCount = checkboxCount;
+    }
+
+    return data;
+  },
+}
diff --git a/server/api/helpers/focalboard/process-uploaded-import-file.js b/server/api/helpers/focalboard/process-uploaded-import-file.js
new file mode 100644
index 000000000..778afa196
--- /dev/null
+++ b/server/api/helpers/focalboard/process-uploaded-import-file.js
@@ -0,0 +1,130 @@
+/*!
+ * 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',
+    },
+    assigneePropertyId: {
+      type: 'string',
+      description: 'Focalboard property ID to use for assignees (maps to CardMembership)',
+    },
+    customFieldPropertyIds: {
+      type: 'ref',
+      description: 'Array of Focalboard property IDs to import as custom fields',
+    },
+    includeFocalboardUrl: {
+      type: 'boolean',
+      defaultsTo: false,
+    },
+    focalboardBaseUrl: {
+      type: 'string',
+    },
+  },
+
+  exits: {
+    invalidFile: {},
+  },
+
+  async fn(inputs) {
+
+    const {
+      file,
+      columnPropertyId,
+      labelPropertyId,
+      dueDatePropertyId,
+      assigneePropertyId,
+      customFieldPropertyIds,
+      includeFocalboardUrl,
+      focalboardBaseUrl,
+    } = inputs;
+
+    const data = await sails.helpers.focalboard
+    .parseFile(file)
+    .intercept('invalidFile', () => 'invalidFile');
+    const { board, views, cards, textBlocks, comments, checkboxes,boardMembers, users } = 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(`Assignee property: ${assigneePropertyId ? 'Yes' : 'None'}`);
+    console.log(`Custom fields: ${customFieldProperties.length}`);
+
+    return {
+      board,
+      views,
+      cards,
+      textBlocks,
+      comments,
+      checkboxes,
+      boardMembers,
+      users,
+      columnProperty,
+      labels,
+      labelPropertyId: effectiveLabelPropertyId,
+      dueDatePropertyId,
+      assigneePropertyId,
+      customFieldProperties,
+      includeFocalboardUrl,
+      focalboardBaseUrl,
+    };
+  },
+};
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/models.js b/server/config/models.js
index 088ab1bbb..0d9ae9260 100644
--- a/server/config/models.js
+++ b/server/config/models.js
@@ -80,8 +80,9 @@ module.exports.models = {
   },
 
   beforeCreate(valuesToSet, proceed) {
-    valuesToSet.createdAt = new Date().toISOString(); // eslint-disable-line no-param-reassign
-
+    if (!valuesToSet.createdAt) {
+      valuesToSet.createdAt = new Date().toISOString(); // eslint-disable-line no-param-reassign
+    }
     proceed();
   },
 
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(