diff --git a/app/controllers/api/v1/accounts/data_imports_controller.rb b/app/controllers/api/v1/accounts/data_imports_controller.rb
index 70432bc33..790cac87d 100644
--- a/app/controllers/api/v1/accounts/data_imports_controller.rb
+++ b/app/controllers/api/v1/accounts/data_imports_controller.rb
@@ -19,14 +19,12 @@ class Api::V1::Accounts::DataImportsController < Api::V1::Accounts::BaseControll
   end
 
   def validate_source
-    totals = validate_intercom_source
+    totals = source_class.credentials_validator(source_params: permitted_params.to_h, import_types: import_types).perform
     render json: { valid: true, totals: totals }
-  rescue DataImports::Intercom::Client::AuthenticationError
-    render_source_validation_error('We could not validate this Intercom access key. Check the key and its permissions.')
-  rescue DataImports::Intercom::Client::Error
-    render_source_validation_error('Intercom could not be reached. Please try again.')
   rescue ArgumentError => e
     render_source_validation_error(e.message)
+  rescue StandardError => e
+    render_source_client_error(e)
   end
 
   def create
@@ -36,44 +34,42 @@ class Api::V1::Accounts::DataImportsController < Api::V1::Accounts::BaseControll
       return
     end
 
-    DataImports::Intercom::ImportJob.perform_later(@data_import, @data_import.active_intercom_import_run_id)
+    enqueue_import(@data_import)
     render_show
-  rescue DataImports::Intercom::Client::AuthenticationError
-    render_source_validation_error('We could not validate this Intercom access key. Check the key and its permissions.')
-  rescue DataImports::Intercom::Client::Error
-    render_source_validation_error('Intercom could not be reached. Please try again.')
   rescue ArgumentError => e
     render_source_validation_error(e.message)
+  rescue StandardError => e
+    render_source_client_error(e)
   end
 
   def start
-    restart_service = DataImports::Intercom::RestartService.new(account: Current.account, data_import: @data_import)
+    restart_service = DataImports::RestartService.new(account: Current.account, data_import: @data_import)
     restart_result = restart_service.perform
     @data_import = restart_service.data_import
     if restart_result == :access_token_missing
-      render json: { message: 'The Intercom access key for this import is unavailable.' }, status: :unprocessable_entity
+      render json: { message: "The #{source_name} #{credential_name} for this import is unavailable." }, status: :unprocessable_entity
       return
     end
 
-    DataImports::Intercom::ImportJob.perform_later(@data_import, @data_import.active_intercom_import_run_id) if restart_result == :enqueue
+    enqueue_import(@data_import) if restart_result == :enqueue
     render_show
   end
 
   def retry_import
-    retry_service = DataImports::Intercom::RetryService.new(account: Current.account, data_import: @data_import)
+    retry_service = DataImports::RetryService.new(account: Current.account, data_import: @data_import)
     retry_result = retry_service.perform
     @data_import = retry_service.data_import
 
     case retry_result
     when :enqueue
-      DataImports::Intercom::ImportJob.perform_later(@data_import, @data_import.active_intercom_import_run_id)
+      enqueue_import(@data_import)
       render_show
     when :not_stalled
-      render json: { message: 'This Intercom import is no longer stalled.' }, status: :unprocessable_entity
+      render json: { message: "This #{source_name} import is no longer stalled." }, status: :unprocessable_entity
     when :active_import_exists
-      render json: { message: 'Another Intercom import is already in progress.' }, status: :unprocessable_entity
+      render json: { message: "Another #{source_name} import is already in progress." }, status: :unprocessable_entity
     when :access_token_missing
-      render json: { message: 'The Intercom access key for this import is unavailable.' }, status: :unprocessable_entity
+      render json: { message: "The #{source_name} #{credential_name} for this import is unavailable." }, status: :unprocessable_entity
     end
   end
 
@@ -113,11 +109,11 @@ class Api::V1::Accounts::DataImportsController < Api::V1::Accounts::BaseControll
   end
 
   def permitted_params
-    params.permit(:name, :source_provider, :access_token, import_types: [])
+    params.permit(:name, :source_provider, :access_token, :domain, import_types: [])
   end
 
   def creation_service
-    DataImports::Intercom::CreationService.new(
+    DataImports::CreationService.new(
       account: Current.account,
       initiated_by: Current.user,
       source_params: permitted_params.to_h
@@ -125,24 +121,50 @@ class Api::V1::Accounts::DataImportsController < Api::V1::Accounts::BaseControll
   end
 
   def import_types
-    return DataImports::Intercom::Importer::DEFAULT_IMPORT_TYPES unless permitted_params.key?(:import_types)
+    return DataImports::Importer::DEFAULT_IMPORT_TYPES unless permitted_params.key?(:import_types)
 
     Array(permitted_params[:import_types]).compact_blank
   end
 
-  def validate_intercom_source
-    raise ArgumentError, 'Unsupported import source.' unless permitted_params[:source_provider] == 'intercom'
+  def source_class
+    provider = @data_import&.source_provider || permitted_params[:source_provider]
+    DataImports::Source.source_class(provider)
+  end
 
-    DataImports::Intercom::CredentialsValidator.new(
-      access_token: permitted_params[:access_token],
-      import_types: import_types
-    ).perform
+  def source_name
+    return 'Integration' unless DataImports::Source.supported?(@data_import&.source_provider || permitted_params[:source_provider])
+
+    source_class::DISPLAY_NAME
+  end
+
+  def credential_name
+    return 'credential' unless DataImports::Source.supported?(@data_import&.source_provider || permitted_params[:source_provider])
+
+    source_class.credential_name
+  end
+
+  def enqueue_import(data_import)
+    DataImports::Source.source_class(data_import.source_provider).import_job_class.perform_later(
+      data_import,
+      data_import.active_import_run_id
+    )
   end
 
   def render_source_validation_error(message)
     render json: { valid: false, message: message }, status: :unprocessable_entity
   end
 
+  def render_source_client_error(error)
+    raise error unless source_class.client_error?(error)
+
+    message = if source_class.authentication_error?(error)
+                "We could not validate this #{source_name} #{credential_name}. Check the key and its permissions."
+              else
+                "#{source_name} could not be reached. Please try again."
+              end
+    render_source_validation_error(message)
+  end
+
   def render_show
     @import_errors_finder = DataImportErrorFinder.new(@data_import)
     @skip_logs_finder = DataImportSkipLogFinder.new(@data_import, params)
diff --git a/app/javascript/dashboard/i18n/locale/en/settings.json b/app/javascript/dashboard/i18n/locale/en/settings.json
index e36732e48..8d1516f3f 100644
--- a/app/javascript/dashboard/i18n/locale/en/settings.json
+++ b/app/javascript/dashboard/i18n/locale/en/settings.json
@@ -421,6 +421,10 @@
     "DESCRIPTION": "Bring your existing contacts and past conversations into this account from another support tool. Each import runs in the background, so you can keep working while it finishes, track its progress, and review anything that was skipped along the way.",
     "LOADING": "Fetching imports",
     "DEFAULT_IMPORT_NAME": "Intercom import",
+    "DEFAULT_IMPORT_NAMES": {
+      "INTERCOM": "Intercom import",
+      "FRESHDESK": "Freshdesk import"
+    },
     "TABS": {
       "IMPORT": "Import",
       "EXPORT": "Export"
@@ -434,9 +438,15 @@
       "TITLE": "New import",
       "SOURCE": "Source",
       "NAME": "Import name",
-      "NAME_PLACEHOLDER": "July Intercom migration",
+      "NAME_PLACEHOLDER": "July support migration",
       "ACCESS_KEY": "Intercom access key",
       "ACCESS_KEY_PLACEHOLDER": "Paste your Intercom access key",
+      "INTERCOM_ACCESS_KEY": "Intercom access key",
+      "INTERCOM_ACCESS_KEY_PLACEHOLDER": "Paste your Intercom access key",
+      "FRESHDESK_API_KEY": "Freshdesk API key",
+      "FRESHDESK_API_KEY_PLACEHOLDER": "Paste your Freshdesk API key",
+      "FRESHDESK_DOMAIN": "Freshdesk domain",
+      "FRESHDESK_DOMAIN_PLACEHOLDER": "acme.freshdesk.com",
       "DATA_TYPES": "Data to import",
       "VALIDATING": "Validating access key...",
       "VALID_KEY": "Access key validated.",
@@ -510,11 +520,11 @@
       }
     },
     "ALERTS": {
-      "IMPORT_STARTED": "Intercom import has started.",
-      "IMPORT_RETRIED": "Intercom import has been queued to resume.",
-      "IMPORT_RETRY_FAILED": "Could not retry the Intercom import.",
-      "IMPORT_ABANDONED": "Intercom import has been abandoned.",
-      "IMPORT_FAILED": "Could not start the Intercom import."
+      "IMPORT_STARTED": "Import has started.",
+      "IMPORT_RETRIED": "Import has been queued to resume.",
+      "IMPORT_RETRY_FAILED": "Could not retry the import.",
+      "IMPORT_ABANDONED": "Import has been abandoned.",
+      "IMPORT_FAILED": "Could not start the import."
     }
   },
   "CAPTAIN_SETTINGS": {
diff --git a/app/javascript/dashboard/routes/dashboard/settings/data/Index.vue b/app/javascript/dashboard/routes/dashboard/settings/data/Index.vue
index 1a11c543a..c34c0a8f6 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/data/Index.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/data/Index.vue
@@ -24,7 +24,7 @@ import {
   formatStatus,
   importedCount,
   isActiveImport,
-  isActiveIntercomImport,
+  isActiveIntegrationImport,
   statusDotClass,
 } from './importStatus';
 
@@ -53,8 +53,8 @@ const activeTabIndex = computed(() =>
 );
 
 const hasActiveImport = computed(() => dataImports.value.some(isActiveImport));
-const hasActiveIntercomImport = computed(() =>
-  dataImports.value.some(isActiveIntercomImport)
+const hasActiveIntegrationImport = computed(() =>
+  dataImports.value.some(isActiveIntegrationImport)
 );
 
 const dataImportRoute = dataImport => ({
@@ -137,7 +137,7 @@ const openImport = dataImport => {
 };
 
 const openImportDrawer = () => {
-  if (!hasActiveIntercomImport.value) showImportDrawer.value = true;
+  if (!hasActiveIntegrationImport.value) showImportDrawer.value = true;
 };
 
 const onImportCreated = dataImportId => {
@@ -227,9 +227,9 @@ onBeforeUnmount(() => {
           <Button
             size="sm"
             :label="$t('DATA_IMPORTS.TABLE.NEW_IMPORT')"
-            :disabled="hasActiveIntercomImport"
+            :disabled="hasActiveIntegrationImport"
             :title="
-              hasActiveIntercomImport
+              hasActiveIntegrationImport
                 ? $t('DATA_IMPORTS.DRAWER.ACTIVE_IMPORT')
                 : undefined
             "
@@ -371,7 +371,7 @@ onBeforeUnmount(() => {
 
   <NewImportDialog
     :show="showImportDrawer"
-    :has-active-import="hasActiveIntercomImport"
+    :has-active-import="hasActiveIntegrationImport"
     @close="showImportDrawer = false"
     @created="onImportCreated"
   />
diff --git a/app/javascript/dashboard/routes/dashboard/settings/data/NewImportDialog.vue b/app/javascript/dashboard/routes/dashboard/settings/data/NewImportDialog.vue
index 56fda08f3..8b8ec0d8f 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/data/NewImportDialog.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/data/NewImportDialog.vue
@@ -8,7 +8,7 @@ import Checkbox from 'dashboard/components-next/checkbox/Checkbox.vue';
 import Input from 'dashboard/components-next/input/Input.vue';
 import Select from 'dashboard/components-next/select/Select.vue';
 import DataImportsAPI from 'dashboard/api/dataImports';
-import { IMPORT_SOURCES } from './importSources';
+import { IMPORT_SOURCES, importSourceConfigFor } from './importSources';
 
 const props = defineProps({
   show: { type: Boolean, default: false },
@@ -20,8 +20,17 @@ const emit = defineEmits(['close', 'created']);
 const { t } = useI18n();
 const dialogRef = ref(null);
 const sourceProvider = ref('intercom');
-const importName = ref(t('DATA_IMPORTS.DEFAULT_IMPORT_NAME'));
+const sourceConfig = computed(
+  () => importSourceConfigFor(sourceProvider.value) || IMPORT_SOURCES[0]
+);
+const defaultImportName = computed(() =>
+  sourceProvider.value === 'freshdesk'
+    ? t('DATA_IMPORTS.DEFAULT_IMPORT_NAMES.FRESHDESK')
+    : t('DATA_IMPORTS.DEFAULT_IMPORT_NAMES.INTERCOM')
+);
+const importName = ref(defaultImportName.value);
 const accessToken = ref('');
+const domain = ref('');
 const selectedImportTypes = ref(['contacts', 'conversations']);
 const validationState = ref('idle');
 const validationMessage = ref('');
@@ -34,6 +43,17 @@ const sourceOptions = computed(() =>
   IMPORT_SOURCES.map(({ value, label }) => ({ value, label }))
 );
 
+const credentialPlaceholder = computed(() =>
+  sourceProvider.value === 'freshdesk'
+    ? t('DATA_IMPORTS.DRAWER.FRESHDESK_API_KEY_PLACEHOLDER')
+    : t('DATA_IMPORTS.DRAWER.INTERCOM_ACCESS_KEY_PLACEHOLDER')
+);
+const credentialLabel = computed(() =>
+  sourceProvider.value === 'freshdesk'
+    ? t('DATA_IMPORTS.DRAWER.FRESHDESK_API_KEY')
+    : t('DATA_IMPORTS.DRAWER.INTERCOM_ACCESS_KEY')
+);
+
 const tokenMessageType = computed(() => {
   if (validationState.value === 'valid') return 'success';
   if (validationState.value === 'invalid') return 'error';
@@ -51,9 +71,14 @@ const canCreate = computed(
 const validationPayload = () => ({
   source_provider: sourceProvider.value,
   access_token: accessToken.value.trim(),
+  ...(sourceConfig.value.requiresDomain ? { domain: domain.value.trim() } : {}),
   import_types: selectedImportTypes.value,
 });
 
+const hasRequiredCredentials = () =>
+  accessToken.value.trim() &&
+  (!sourceConfig.value.requiresDomain || domain.value.trim());
+
 const invalidateValidation = () => {
   validationRequestId += 1;
   validationState.value = 'idle';
@@ -61,7 +86,7 @@ const invalidateValidation = () => {
 };
 
 const validateSource = async () => {
-  if (!accessToken.value.trim() || !selectedImportTypes.value.length) {
+  if (!hasRequiredCredentials() || !selectedImportTypes.value.length) {
     invalidateValidation();
     return;
   }
@@ -98,7 +123,7 @@ const createImport = async () => {
   try {
     const response = await DataImportsAPI.create({
       ...validationPayload(),
-      name: importName.value.trim() || t('DATA_IMPORTS.DEFAULT_IMPORT_NAME'),
+      name: importName.value.trim() || defaultImportName.value,
     });
     useAlert(t('DATA_IMPORTS.ALERTS.IMPORT_STARTED'));
     emit('created', response.data.id);
@@ -112,10 +137,18 @@ const createImport = async () => {
 };
 
 watch(accessToken, invalidateValidation);
+watch(domain, invalidateValidation);
+
+watch(sourceProvider, () => {
+  importName.value = defaultImportName.value;
+  accessToken.value = '';
+  domain.value = '';
+  invalidateValidation();
+});
 
 watch(selectedImportTypes, () => {
   invalidateValidation();
-  if (accessToken.value.trim() && selectedImportTypes.value.length) {
+  if (hasRequiredCredentials() && selectedImportTypes.value.length) {
     validateSource();
   }
 });
@@ -130,6 +163,7 @@ watch(
 
     dialogRef.value?.close();
     accessToken.value = '';
+    domain.value = '';
     validationState.value = 'idle';
     validationMessage.value = '';
   }
@@ -164,12 +198,21 @@ watch(
         :placeholder="$t('DATA_IMPORTS.DRAWER.NAME_PLACEHOLDER')"
       />
 
+      <Input
+        v-if="sourceConfig.requiresDomain"
+        v-model="domain"
+        autocomplete="off"
+        :label="$t('DATA_IMPORTS.DRAWER.FRESHDESK_DOMAIN')"
+        :placeholder="$t('DATA_IMPORTS.DRAWER.FRESHDESK_DOMAIN_PLACEHOLDER')"
+        @blur="validateSource"
+      />
+
       <Input
         v-model="accessToken"
         type="password"
         autocomplete="off"
-        :label="$t('DATA_IMPORTS.DRAWER.ACCESS_KEY')"
-        :placeholder="$t('DATA_IMPORTS.DRAWER.ACCESS_KEY_PLACEHOLDER')"
+        :label="credentialLabel"
+        :placeholder="credentialPlaceholder"
         :message="validationMessage"
         :message-type="tokenMessageType"
         @blur="validateSource"
diff --git a/app/javascript/dashboard/routes/dashboard/settings/data/importSources.js b/app/javascript/dashboard/routes/dashboard/settings/data/importSources.js
index 85e832a6c..65bdf7a1b 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/data/importSources.js
+++ b/app/javascript/dashboard/routes/dashboard/settings/data/importSources.js
@@ -4,8 +4,17 @@ export const IMPORT_SOURCES = [
     label: 'Intercom',
     icon: '/dashboard/images/integrations/intercom.png',
   },
+  {
+    value: 'freshdesk',
+    label: 'Freshdesk',
+    iconClass: 'i-lucide-life-buoy',
+    requiresDomain: true,
+  },
 ];
 
+export const importSourceConfigFor = provider =>
+  IMPORT_SOURCES.find(source => source.value === provider);
+
 const DEFAULT_IMPORT_SOURCE = {
   value: 'file',
   label: 'File import',
@@ -13,5 +22,4 @@ const DEFAULT_IMPORT_SOURCE = {
 };
 
 export const importSourceFor = dataImport =>
-  IMPORT_SOURCES.find(source => source.value === dataImport?.source_provider) ||
-  DEFAULT_IMPORT_SOURCE;
+  importSourceConfigFor(dataImport?.source_provider) || DEFAULT_IMPORT_SOURCE;
diff --git a/app/javascript/dashboard/routes/dashboard/settings/data/importStatus.js b/app/javascript/dashboard/routes/dashboard/settings/data/importStatus.js
index f658ee04c..d24465ce3 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/data/importStatus.js
+++ b/app/javascript/dashboard/routes/dashboard/settings/data/importStatus.js
@@ -9,14 +9,21 @@ export const isIntercomImport = dataImport =>
   dataImport?.data_type === 'intercom' &&
   dataImport?.source_provider === 'intercom';
 
+export const isIntegrationImport = dataImport =>
+  ['freshdesk', 'intercom'].includes(dataImport?.data_type) &&
+  dataImport?.data_type === dataImport?.source_provider;
+
 export const isActiveIntercomImport = dataImport =>
   isIntercomImport(dataImport) && isActiveImport(dataImport);
 
+export const isActiveIntegrationImport = dataImport =>
+  isIntegrationImport(dataImport) && isActiveImport(dataImport);
+
 export const isAbandonableImport = dataImport =>
-  isActiveIntercomImport(dataImport);
+  isActiveIntegrationImport(dataImport);
 
 export const importedCount = dataImport => {
-  if (!isIntercomImport(dataImport)) {
+  if (!isIntegrationImport(dataImport)) {
     return Number(dataImport?.processed_records || 0);
   }
 
diff --git a/app/javascript/dashboard/routes/dashboard/settings/data/specs/NewImportDialog.spec.js b/app/javascript/dashboard/routes/dashboard/settings/data/specs/NewImportDialog.spec.js
new file mode 100644
index 000000000..4f672b1c2
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/settings/data/specs/NewImportDialog.spec.js
@@ -0,0 +1,104 @@
+import { flushPromises, mount } from '@vue/test-utils';
+import { nextTick } from 'vue';
+import DataImportsAPI from 'dashboard/api/dataImports';
+import NewImportDialog from '../NewImportDialog.vue';
+
+vi.mock('dashboard/api/dataImports', () => ({
+  default: {
+    validateSource: vi.fn(),
+    create: vi.fn(),
+  },
+}));
+
+vi.mock('dashboard/composables', () => ({
+  useAlert: vi.fn(),
+}));
+
+vi.mock('vue-i18n', () => ({
+  useI18n: () => ({ t: key => key }),
+}));
+
+const DialogStub = {
+  name: 'Dialog',
+  props: {
+    disableConfirmButton: { type: Boolean, default: false },
+  },
+  emits: ['close', 'confirm'],
+  methods: {
+    open() {},
+    close() {},
+  },
+  template: `
+    <section>
+      <slot />
+      <button
+        data-test="confirm"
+        :disabled="disableConfirmButton"
+        @click="$emit('confirm')"
+      />
+    </section>
+  `,
+};
+
+const mountDialog = () =>
+  mount(NewImportDialog, {
+    props: { show: true },
+    global: {
+      stubs: {
+        Dialog: DialogStub,
+        Checkbox: true,
+      },
+      mocks: {
+        $t: key => key,
+      },
+    },
+  });
+
+describe('NewImportDialog', () => {
+  beforeEach(() => {
+    DataImportsAPI.validateSource.mockResolvedValue({
+      data: { valid: true, totals: {} },
+    });
+    DataImportsAPI.create.mockResolvedValue({ data: { id: 42 } });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('validates and creates a Freshdesk import with its domain', async () => {
+    const wrapper = mountDialog();
+    await wrapper.find('select').setValue('freshdesk');
+    await nextTick();
+
+    const domainInput = wrapper.find(
+      'input[placeholder="DATA_IMPORTS.DRAWER.FRESHDESK_DOMAIN_PLACEHOLDER"]'
+    );
+    const apiKeyInput = wrapper.find(
+      'input[placeholder="DATA_IMPORTS.DRAWER.FRESHDESK_API_KEY_PLACEHOLDER"]'
+    );
+    await domainInput.setValue('acme.freshdesk.com');
+    await apiKeyInput.setValue(' freshdesk-api-key ');
+    await apiKeyInput.trigger('blur');
+    await flushPromises();
+
+    expect(DataImportsAPI.validateSource).toHaveBeenCalledWith({
+      source_provider: 'freshdesk',
+      domain: 'acme.freshdesk.com',
+      access_token: 'freshdesk-api-key',
+      import_types: ['contacts', 'conversations'],
+    });
+
+    await wrapper.find('[data-test="confirm"]').trigger('click');
+    await flushPromises();
+
+    expect(DataImportsAPI.create).toHaveBeenCalledWith({
+      source_provider: 'freshdesk',
+      domain: 'acme.freshdesk.com',
+      access_token: 'freshdesk-api-key',
+      import_types: ['contacts', 'conversations'],
+      name: 'DATA_IMPORTS.DEFAULT_IMPORT_NAMES.FRESHDESK',
+    });
+    expect(wrapper.emitted('created')).toEqual([[42]]);
+  });
+});
diff --git a/app/javascript/dashboard/routes/dashboard/settings/data/specs/importSources.spec.js b/app/javascript/dashboard/routes/dashboard/settings/data/specs/importSources.spec.js
new file mode 100644
index 000000000..27222a3c9
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/settings/data/specs/importSources.spec.js
@@ -0,0 +1,28 @@
+import {
+  IMPORT_SOURCES,
+  importSourceConfigFor,
+  importSourceFor,
+} from '../importSources';
+
+describe('importSources', () => {
+  it('exposes Freshdesk as a domain-based integration source', () => {
+    expect(IMPORT_SOURCES.map(source => source.value)).toEqual([
+      'intercom',
+      'freshdesk',
+    ]);
+    expect(importSourceConfigFor('freshdesk')).toMatchObject({
+      label: 'Freshdesk',
+      requiresDomain: true,
+    });
+  });
+
+  it('resolves persisted integrations and falls back for file imports', () => {
+    expect(importSourceFor({ source_provider: 'freshdesk' }).label).toBe(
+      'Freshdesk'
+    );
+    expect(importSourceFor({ source_provider: null })).toMatchObject({
+      value: 'file',
+      label: 'File import',
+    });
+  });
+});
diff --git a/app/javascript/dashboard/routes/dashboard/settings/data/specs/importStatus.spec.js b/app/javascript/dashboard/routes/dashboard/settings/data/specs/importStatus.spec.js
index dcfe7d9bd..1ff0e2e82 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/data/specs/importStatus.spec.js
+++ b/app/javascript/dashboard/routes/dashboard/settings/data/specs/importStatus.spec.js
@@ -2,6 +2,7 @@ import {
   formatDate,
   importedCount,
   isActiveIntercomImport,
+  isActiveIntegrationImport,
   statusDotClass,
 } from '../importStatus';
 
@@ -32,12 +33,38 @@ describe('importStatus', () => {
     });
   });
 
-  describe('importedCount', () => {
-    it('sums Intercom imported stats', () => {
+  describe('isActiveIntegrationImport', () => {
+    it('treats matching Freshdesk and Intercom imports as active', () => {
       expect(
-        importedCount({
+        isActiveIntegrationImport({
+          data_type: 'freshdesk',
+          source_provider: 'freshdesk',
+          status: 'pending',
+        })
+      ).toBe(true);
+      expect(
+        isActiveIntegrationImport({
           data_type: 'intercom',
           source_provider: 'intercom',
+          status: 'processing',
+        })
+      ).toBe(true);
+      expect(
+        isActiveIntegrationImport({
+          data_type: 'freshdesk',
+          source_provider: 'intercom',
+          status: 'processing',
+        })
+      ).toBe(false);
+    });
+  });
+
+  describe('importedCount', () => {
+    it('sums integration imported stats', () => {
+      expect(
+        importedCount({
+          data_type: 'freshdesk',
+          source_provider: 'freshdesk',
           processed_records: 20,
           stats: {
             contacts: { imported: 2 },
diff --git a/app/jobs/data_imports/base_job.rb b/app/jobs/data_imports/base_job.rb
new file mode 100644
index 000000000..ac69c2ced
--- /dev/null
+++ b/app/jobs/data_imports/base_job.rb
@@ -0,0 +1,47 @@
+class DataImports::BaseJob < ApplicationJob
+  queue_as :low
+
+  def fail_import!(error)
+    data_import = arguments.first
+    run_id = arguments.length > 1 ? arguments.last : nil
+    return if data_import.blank? || skip_import?(data_import, run_id)
+
+    importer_for(data_import, run_id).fail!(error)
+  end
+
+  private
+
+  def skip_import?(data_import, run_id = nil)
+    data_import.reload
+    data_import.abandoned? || data_import.failed? || data_import.completed? ||
+      data_import.completed_with_errors? || stale_import_run?(data_import, run_id)
+  end
+
+  def stale_import_run?(data_import, run_id)
+    active_run_id = data_import.active_import_run_id
+    active_run_id.present? && active_run_id != run_id
+  end
+
+  def importer_for(data_import, run_id = nil)
+    source_class(data_import).importer_class.new(data_import: data_import, run_id: run_id)
+  end
+
+  def fail_unexpected_error(importer, error)
+    raise error if source_class(arguments.first).client_error?(error)
+
+    importer&.fail!(error)
+    raise error
+  end
+
+  def contacts_page_job_class(data_import)
+    source_class(data_import).contacts_page_job_class
+  end
+
+  def conversations_page_job_class(data_import)
+    source_class(data_import).conversations_page_job_class
+  end
+
+  def source_class(data_import)
+    DataImports::Source.source_class(data_import.source_provider)
+  end
+end
diff --git a/app/jobs/data_imports/contacts_page_job.rb b/app/jobs/data_imports/contacts_page_job.rb
new file mode 100644
index 000000000..196ccd2c1
--- /dev/null
+++ b/app/jobs/data_imports/contacts_page_job.rb
@@ -0,0 +1,26 @@
+module DataImports::ContactsPageJob
+  def perform(data_import, starting_after = nil, run_id = nil)
+    return if skip_import?(data_import, run_id)
+
+    importer = importer_for(data_import, run_id)
+    return enqueue_conversations_or_finish(data_import, importer, run_id) if importer.contacts_completed?
+
+    result = importer.import_contacts_page(starting_after: starting_after)
+    return if skip_import?(data_import, run_id)
+    return self.class.perform_later(data_import, result.next_cursor, run_id) unless result.done?
+
+    enqueue_conversations_or_finish(data_import, importer, run_id)
+  rescue StandardError => e
+    fail_unexpected_error(importer, e)
+  end
+
+  private
+
+  def enqueue_conversations_or_finish(data_import, importer, run_id)
+    if importer.import_conversations? && !importer.conversations_completed?
+      conversations_page_job_class(data_import).perform_later(data_import, importer.cursor_for('conversations'), run_id)
+    else
+      importer.finish!
+    end
+  end
+end
diff --git a/app/jobs/data_imports/conversations_page_job.rb b/app/jobs/data_imports/conversations_page_job.rb
new file mode 100644
index 000000000..587833360
--- /dev/null
+++ b/app/jobs/data_imports/conversations_page_job.rb
@@ -0,0 +1,16 @@
+module DataImports::ConversationsPageJob
+  def perform(data_import, starting_after = nil, run_id = nil)
+    return if skip_import?(data_import, run_id)
+
+    importer = importer_for(data_import, run_id)
+    return importer.finish! if importer.conversations_completed?
+
+    result = importer.import_conversations_page(starting_after: starting_after)
+    return if skip_import?(data_import, run_id)
+    return self.class.perform_later(data_import, result.next_cursor, run_id) unless result.done?
+
+    importer.finish!
+  rescue StandardError => e
+    fail_unexpected_error(importer, e)
+  end
+end
diff --git a/app/jobs/data_imports/freshdesk/base_job.rb b/app/jobs/data_imports/freshdesk/base_job.rb
new file mode 100644
index 000000000..dd8405e5f
--- /dev/null
+++ b/app/jobs/data_imports/freshdesk/base_job.rb
@@ -0,0 +1,26 @@
+class DataImports::Freshdesk::BaseJob < DataImports::BaseJob
+  DEFAULT_RATE_LIMIT_WAIT = 1.minute
+
+  retry_on DataImports::Freshdesk::Client::Error, wait: 1.minute, attempts: 3 do |job, error|
+    job.fail_import!(error)
+  end
+
+  retry_on DataImports::Freshdesk::Client::RateLimitError, wait: DEFAULT_RATE_LIMIT_WAIT, attempts: 5 do |job, error|
+    job.fail_import!(error)
+  end
+
+  discard_on CustomExceptions::DataImport::FreshdeskTicketLimitError
+
+  def retry_job(options = {})
+    error = options[:error]
+    options = options.merge(wait: rate_limit_wait(error)) if error.is_a?(DataImports::Freshdesk::Client::RateLimitError)
+    super(options)
+  end
+
+  private
+
+  def rate_limit_wait(error)
+    retry_after = error.retry_after.to_i
+    retry_after.positive? ? retry_after.seconds : DEFAULT_RATE_LIMIT_WAIT
+  end
+end
diff --git a/app/jobs/data_imports/freshdesk/contacts_page_job.rb b/app/jobs/data_imports/freshdesk/contacts_page_job.rb
new file mode 100644
index 000000000..a0126ea48
--- /dev/null
+++ b/app/jobs/data_imports/freshdesk/contacts_page_job.rb
@@ -0,0 +1,3 @@
+class DataImports::Freshdesk::ContactsPageJob < DataImports::Freshdesk::BaseJob
+  include DataImports::ContactsPageJob
+end
diff --git a/app/jobs/data_imports/freshdesk/conversations_page_job.rb b/app/jobs/data_imports/freshdesk/conversations_page_job.rb
new file mode 100644
index 000000000..4f14f0fab
--- /dev/null
+++ b/app/jobs/data_imports/freshdesk/conversations_page_job.rb
@@ -0,0 +1,3 @@
+class DataImports::Freshdesk::ConversationsPageJob < DataImports::Freshdesk::BaseJob
+  include DataImports::ConversationsPageJob
+end
diff --git a/app/jobs/data_imports/freshdesk/import_job.rb b/app/jobs/data_imports/freshdesk/import_job.rb
new file mode 100644
index 000000000..05bdb8871
--- /dev/null
+++ b/app/jobs/data_imports/freshdesk/import_job.rb
@@ -0,0 +1,3 @@
+class DataImports::Freshdesk::ImportJob < DataImports::Freshdesk::BaseJob
+  include DataImports::ImportJob
+end
diff --git a/app/jobs/data_imports/import_job.rb b/app/jobs/data_imports/import_job.rb
new file mode 100644
index 000000000..49a96186d
--- /dev/null
+++ b/app/jobs/data_imports/import_job.rb
@@ -0,0 +1,24 @@
+module DataImports::ImportJob
+  def perform(data_import, run_id = nil)
+    return if skip_import?(data_import, run_id)
+
+    importer = importer_for(data_import, run_id)
+    return unless importer.start!
+
+    enqueue_next_stage(data_import, importer, run_id)
+  rescue StandardError => e
+    fail_unexpected_error(importer, e)
+  end
+
+  private
+
+  def enqueue_next_stage(data_import, importer, run_id)
+    if importer.import_contacts? && !importer.contacts_completed?
+      contacts_page_job_class(data_import).perform_later(data_import, importer.cursor_for('contacts'), run_id)
+    elsif importer.import_conversations? && !importer.conversations_completed?
+      conversations_page_job_class(data_import).perform_later(data_import, importer.cursor_for('conversations'), run_id)
+    else
+      importer.finish!
+    end
+  end
+end
diff --git a/app/jobs/data_imports/intercom/base_job.rb b/app/jobs/data_imports/intercom/base_job.rb
index d4842c061..b6f8221df 100644
--- a/app/jobs/data_imports/intercom/base_job.rb
+++ b/app/jobs/data_imports/intercom/base_job.rb
@@ -1,6 +1,4 @@
-class DataImports::Intercom::BaseJob < ApplicationJob
-  queue_as :low
-
+class DataImports::Intercom::BaseJob < DataImports::BaseJob
   retry_on DataImports::Intercom::Client::Error, wait: 1.minute, attempts: 3 do |job, error|
     job.fail_import!(error)
   end
@@ -8,36 +6,4 @@ class DataImports::Intercom::BaseJob < ApplicationJob
   retry_on DataImports::Intercom::Client::RateLimitError, wait: 1.minute, attempts: 5 do |job, error|
     job.fail_import!(error)
   end
-
-  def fail_import!(error)
-    data_import = arguments.first
-    run_id = arguments.length > 1 ? arguments.last : nil
-    return if data_import.blank? || skip_import?(data_import, run_id)
-
-    DataImports::Intercom::Importer.new(data_import: data_import, run_id: run_id).fail!(error)
-  end
-
-  private
-
-  def skip_import?(data_import, run_id = nil)
-    data_import.reload
-    data_import.abandoned? || data_import.failed? || data_import.completed? ||
-      data_import.completed_with_errors? || stale_import_run?(data_import, run_id)
-  end
-
-  def stale_import_run?(data_import, run_id)
-    active_run_id = data_import.active_intercom_import_run_id
-    active_run_id.present? && active_run_id != run_id
-  end
-
-  def importer_for(data_import, run_id = nil)
-    DataImports::Intercom::Importer.new(data_import: data_import, run_id: run_id)
-  end
-
-  def fail_unexpected_error(importer, error)
-    raise error if error.is_a?(DataImports::Intercom::Client::Error)
-
-    importer&.fail!(error)
-    raise error
-  end
 end
diff --git a/app/jobs/data_imports/intercom/contacts_page_job.rb b/app/jobs/data_imports/intercom/contacts_page_job.rb
index 89f51a5b4..4ec4acbec 100644
--- a/app/jobs/data_imports/intercom/contacts_page_job.rb
+++ b/app/jobs/data_imports/intercom/contacts_page_job.rb
@@ -1,26 +1,3 @@
 class DataImports::Intercom::ContactsPageJob < DataImports::Intercom::BaseJob
-  def perform(data_import, starting_after = nil, run_id = nil)
-    return if skip_import?(data_import, run_id)
-
-    importer = importer_for(data_import, run_id)
-    return enqueue_conversations_or_finish(data_import, importer, run_id) if importer.contacts_completed?
-
-    result = importer.import_contacts_page(starting_after: starting_after)
-    return if skip_import?(data_import, run_id)
-    return self.class.perform_later(data_import, result.next_cursor, run_id) unless result.done?
-
-    enqueue_conversations_or_finish(data_import, importer, run_id)
-  rescue StandardError => e
-    fail_unexpected_error(importer, e)
-  end
-
-  private
-
-  def enqueue_conversations_or_finish(data_import, importer, run_id)
-    if importer.import_conversations? && !importer.conversations_completed?
-      DataImports::Intercom::ConversationsPageJob.perform_later(data_import, importer.cursor_for('conversations'), run_id)
-    else
-      importer.finish!
-    end
-  end
+  include DataImports::ContactsPageJob
 end
diff --git a/app/jobs/data_imports/intercom/conversations_page_job.rb b/app/jobs/data_imports/intercom/conversations_page_job.rb
index 8b8d92e6d..95e322aea 100644
--- a/app/jobs/data_imports/intercom/conversations_page_job.rb
+++ b/app/jobs/data_imports/intercom/conversations_page_job.rb
@@ -1,16 +1,3 @@
 class DataImports::Intercom::ConversationsPageJob < DataImports::Intercom::BaseJob
-  def perform(data_import, starting_after = nil, run_id = nil)
-    return if skip_import?(data_import, run_id)
-
-    importer = importer_for(data_import, run_id)
-    return importer.finish! if importer.conversations_completed?
-
-    result = importer.import_conversations_page(starting_after: starting_after)
-    return if skip_import?(data_import, run_id)
-    return self.class.perform_later(data_import, result.next_cursor, run_id) unless result.done?
-
-    importer.finish!
-  rescue StandardError => e
-    fail_unexpected_error(importer, e)
-  end
+  include DataImports::ConversationsPageJob
 end
diff --git a/app/jobs/data_imports/intercom/import_job.rb b/app/jobs/data_imports/intercom/import_job.rb
index 1b054669c..012d078c8 100644
--- a/app/jobs/data_imports/intercom/import_job.rb
+++ b/app/jobs/data_imports/intercom/import_job.rb
@@ -1,24 +1,3 @@
 class DataImports::Intercom::ImportJob < DataImports::Intercom::BaseJob
-  def perform(data_import, run_id = nil)
-    return if skip_import?(data_import, run_id)
-
-    importer = importer_for(data_import, run_id)
-    return unless importer.start!
-
-    enqueue_next_stage(data_import, importer, run_id)
-  rescue StandardError => e
-    fail_unexpected_error(importer, e)
-  end
-
-  private
-
-  def enqueue_next_stage(data_import, importer, run_id)
-    if importer.import_contacts? && !importer.contacts_completed?
-      DataImports::Intercom::ContactsPageJob.perform_later(data_import, importer.cursor_for('contacts'), run_id)
-    elsif importer.import_conversations? && !importer.conversations_completed?
-      DataImports::Intercom::ConversationsPageJob.perform_later(data_import, importer.cursor_for('conversations'), run_id)
-    else
-      importer.finish!
-    end
-  end
+  include DataImports::ImportJob
 end
diff --git a/app/models/concerns/out_of_offisable.rb b/app/models/concerns/out_of_offisable.rb
index 9b9a59a19..20ddcc109 100644
--- a/app/models/concerns/out_of_offisable.rb
+++ b/app/models/concerns/out_of_offisable.rb
@@ -4,6 +4,15 @@ module OutOfOffisable
   extend ActiveSupport::Concern
 
   OFFISABLE_ATTRS = %w[day_of_week closed_all_day open_hour open_minutes close_hour close_minutes open_all_day].freeze
+  DEFAULT_WORKING_HOURS = [
+    { day_of_week: 0, closed_all_day: true, open_all_day: false },
+    { day_of_week: 1, open_hour: 9, open_minutes: 0, close_hour: 17, close_minutes: 0, open_all_day: false },
+    { day_of_week: 2, open_hour: 9, open_minutes: 0, close_hour: 17, close_minutes: 0, open_all_day: false },
+    { day_of_week: 3, open_hour: 9, open_minutes: 0, close_hour: 17, close_minutes: 0, open_all_day: false },
+    { day_of_week: 4, open_hour: 9, open_minutes: 0, close_hour: 17, close_minutes: 0, open_all_day: false },
+    { day_of_week: 5, open_hour: 9, open_minutes: 0, close_hour: 17, close_minutes: 0, open_all_day: false },
+    { day_of_week: 6, closed_all_day: true, open_all_day: false }
+  ].map(&:freeze).freeze
 
   included do
     has_many :working_hours, dependent: :destroy_async
@@ -52,12 +61,6 @@ module OutOfOffisable
   private
 
   def create_default_working_hours
-    working_hours.create!(day_of_week: 0, closed_all_day: true, open_all_day: false)
-    working_hours.create!(day_of_week: 1, open_hour: 9, open_minutes: 0, close_hour: 17, close_minutes: 0, open_all_day: false)
-    working_hours.create!(day_of_week: 2, open_hour: 9, open_minutes: 0, close_hour: 17, close_minutes: 0, open_all_day: false)
-    working_hours.create!(day_of_week: 3, open_hour: 9, open_minutes: 0, close_hour: 17, close_minutes: 0, open_all_day: false)
-    working_hours.create!(day_of_week: 4, open_hour: 9, open_minutes: 0, close_hour: 17, close_minutes: 0, open_all_day: false)
-    working_hours.create!(day_of_week: 5, open_hour: 9, open_minutes: 0, close_hour: 17, close_minutes: 0, open_all_day: false)
-    working_hours.create!(day_of_week: 6, closed_all_day: true, open_all_day: false)
+    DEFAULT_WORKING_HOURS.each { |attributes| working_hours.create!(attributes) }
   end
 end
diff --git a/app/models/data_import.rb b/app/models/data_import.rb
index c78c3ce0b..1c9cfa7fd 100644
--- a/app/models/data_import.rb
+++ b/app/models/data_import.rb
@@ -32,10 +32,12 @@
 #  index_data_imports_on_source_provider  (source_provider)
 #
 class DataImport < ApplicationRecord
+  ACTIVE_IMPORT_RUN_ID_KEY = 'active_import_run_id'.freeze
   ACTIVE_INTERCOM_IMPORT_RUN_ID_KEY = 'active_intercom_import_run_id'.freeze
-  INTERCOM_STALLED_AFTER = 15.minutes
+  IMPORT_STALLED_AFTER = 15.minutes
+  INTERCOM_STALLED_AFTER = IMPORT_STALLED_AFTER
   LEGACY_DATA_TYPES = ['contacts'].freeze
-  INTEGRATION_DATA_TYPES = ['intercom'].freeze
+  INTEGRATION_DATA_TYPES = %w[freshdesk intercom].freeze
   IMPORT_TYPES = %w[contacts conversations].freeze
 
   belongs_to :account
@@ -48,12 +50,16 @@ class DataImport < ApplicationRecord
   has_many :import_errors, class_name: 'DataImportError', dependent: :destroy_async
 
   validates :data_type, inclusion: { in: LEGACY_DATA_TYPES + INTEGRATION_DATA_TYPES, message: I18n.t('errors.data_import.data_type.invalid') }
-  validates :access_token, presence: true, on: :create, if: :intercom_import?
+  validates :access_token, presence: true, on: :create, if: :integration_import?
   validate :validate_import_types
+  validate :validate_integration_provider
 
   enum status: { pending: 0, processing: 1, completed: 2, failed: 3, completed_with_errors: 6, abandoned: 7 }
 
   scope :active_intercom, -> { where(data_type: 'intercom', source_provider: 'intercom', status: [:pending, :processing]) }
+  scope :active_integrations, lambda {
+    where(data_type: INTEGRATION_DATA_TYPES, status: [:pending, :processing]).where('source_provider = data_type')
+  }
 
   has_one_attached :import_file
   has_one_attached :failed_records
@@ -68,38 +74,52 @@ class DataImport < ApplicationRecord
     data_type == 'intercom' && source_provider == 'intercom'
   end
 
+  def freshdesk_import?
+    data_type == 'freshdesk' && source_provider == 'freshdesk'
+  end
+
+  def integration_import?
+    INTEGRATION_DATA_TYPES.include?(data_type) && data_type == source_provider
+  end
+
   def restartable?
     failed? || abandoned?
   end
 
   def stalled?
-    intercom_import? && (pending? || processing?) && updated_at <= INTERCOM_STALLED_AFTER.ago
+    integration_import? && (pending? || processing?) && updated_at <= IMPORT_STALLED_AFTER.ago
   end
 
   def abandonable?
-    intercom_import? && (pending? || processing?)
+    integration_import? && (pending? || processing?)
   end
 
   def abandon!
     self.class.transaction do
-      abandonable_import = self.class.lock.find_by(
-        id: id,
-        data_type: 'intercom',
-        source_provider: 'intercom',
-        status: [:pending, :processing]
-      )
+      active_imports = self.class.lock.where(id: id, data_type: INTEGRATION_DATA_TYPES, status: [:pending, :processing])
+      abandonable_import = active_imports.where('source_provider = data_type').first
       abandonable_import&.update!(status: :abandoned, abandoned_at: Time.current)
     end
     reload
   end
 
   def active_intercom_import_run_id
-    source_metadata.to_h[ACTIVE_INTERCOM_IMPORT_RUN_ID_KEY]
+    active_import_run_id
   end
 
   def assign_active_intercom_import_run_id
-    self.source_metadata = source_metadata.to_h.merge(ACTIVE_INTERCOM_IMPORT_RUN_ID_KEY => SecureRandom.uuid)
-    active_intercom_import_run_id
+    assign_active_import_run_id
+  end
+
+  def active_import_run_id
+    source_metadata.to_h[ACTIVE_IMPORT_RUN_ID_KEY] || source_metadata.to_h[ACTIVE_INTERCOM_IMPORT_RUN_ID_KEY]
+  end
+
+  def assign_active_import_run_id
+    run_id = SecureRandom.uuid
+    self.source_metadata = source_metadata.to_h.merge(ACTIVE_IMPORT_RUN_ID_KEY => run_id)
+    source_metadata[ACTIVE_INTERCOM_IMPORT_RUN_ID_KEY] = run_id if intercom_import?
+    run_id
   end
 
   private
@@ -119,4 +139,11 @@ class DataImport < ApplicationRecord
 
     errors.add(:import_types, "contains unsupported values: #{invalid_types.join(', ')}")
   end
+
+  def validate_integration_provider
+    return unless INTEGRATION_DATA_TYPES.include?(data_type)
+    return if source_provider == data_type
+
+    errors.add(:source_provider, 'must match the integration data type')
+  end
 end
diff --git a/app/services/data_imports/creation_service.rb b/app/services/data_imports/creation_service.rb
new file mode 100644
index 000000000..202ca8f10
--- /dev/null
+++ b/app/services/data_imports/creation_service.rb
@@ -0,0 +1,65 @@
+class DataImports::CreationService
+  def initialize(account:, initiated_by:, source_params:)
+    @account = account
+    @initiated_by = initiated_by
+    @source_params = source_params.symbolize_keys
+    @access_token = @source_params[:access_token].to_s.strip
+    @provider = @source_params[:source_provider].to_s
+    @source_class = DataImports::Source.source_class(@provider)
+  end
+
+  def perform
+    return if active_import?
+
+    totals = validate_source
+    @account.with_lock do
+      next if active_import?
+
+      @account.data_imports.new(attributes(totals)).tap do |data_import|
+        data_import.assign_active_import_run_id
+        data_import.save!
+      end
+    end
+  end
+
+  private
+
+  def validate_source
+    @source_class.credentials_validator(source_params: @source_params, import_types: import_types).perform
+  end
+
+  def attributes(totals)
+    {
+      name: @source_params[:name].presence || @source_class.default_import_name,
+      data_type: @provider,
+      source_type: 'api',
+      source_provider: @provider,
+      import_types: import_types,
+      initiated_by: @initiated_by,
+      access_token: @access_token,
+      source_metadata: @source_class.source_metadata(@source_params),
+      stats: initial_stats(totals)
+    }
+  end
+
+  def import_types
+    return DataImports::Importer::DEFAULT_IMPORT_TYPES unless @source_params.key?(:import_types)
+
+    Array(@source_params[:import_types]).compact_blank
+  end
+
+  def initial_stats(totals)
+    {
+      'contacts' => { 'imported' => 0, 'skipped' => 0 },
+      'conversations' => { 'imported' => 0, 'skipped' => 0 },
+      'messages' => { 'imported' => 0, 'skipped' => 0 },
+      'errors' => { 'count' => 0 }
+    }.tap do |stats|
+      totals.each { |type, total| stats[type]['total'] = total unless total.nil? }
+    end
+  end
+
+  def active_import?
+    @account.data_imports.active_integrations.exists?
+  end
+end
diff --git a/app/services/data_imports/freshdesk/client.rb b/app/services/data_imports/freshdesk/client.rb
new file mode 100644
index 000000000..5ad433807
--- /dev/null
+++ b/app/services/data_imports/freshdesk/client.rb
@@ -0,0 +1,160 @@
+require 'uri'
+
+class DataImports::Freshdesk::Client
+  class Error < StandardError
+    attr_reader :status, :body
+
+    def initialize(message, status: nil, body: nil)
+      super(message)
+      @status = status
+      @body = body
+    end
+  end
+
+  class AuthenticationError < Error; end
+
+  class RateLimitError < Error
+    attr_reader :retry_after
+
+    def initialize(message, retry_after: nil, **)
+      super(message, **)
+      @retry_after = retry_after
+    end
+  end
+
+  Page = Struct.new(:data, :next_page, keyword_init: true)
+
+  DEFAULT_PER_PAGE = 100
+  MAX_TICKET_PAGES = 300
+  EARLIEST_TICKET_TIMESTAMP = '1970-01-01T00:00:00Z'.freeze
+  FRESHDESK_DOMAIN_REGEX = /\A[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.freshdesk\.com\z/i
+
+  attr_reader :domain
+
+  def self.normalize_domain(value)
+    candidate = value.to_s.strip.downcase
+    candidate = "#{candidate}.freshdesk.com" unless candidate.include?('.')
+    candidate = URI.parse(candidate).host if candidate.start_with?('http://', 'https://')
+    raise ArgumentError, 'Enter a valid Freshdesk domain, such as acme.freshdesk.com.' unless candidate&.match?(FRESHDESK_DOMAIN_REGEX)
+
+    candidate
+  rescue URI::InvalidURIError
+    raise ArgumentError, 'Enter a valid Freshdesk domain, such as acme.freshdesk.com.'
+  end
+
+  def initialize(domain:, api_key:)
+    @domain = self.class.normalize_domain(domain)
+    @api_key = api_key.to_s.strip
+  end
+
+  def list_contacts(page: 1, per_page: DEFAULT_PER_PAGE)
+    get_page('/contacts', query: { page: page, per_page: per_page })
+  end
+
+  def retrieve_contact(id)
+    get("/contacts/#{id}")
+  end
+
+  def list_tickets(page: 1, per_page: DEFAULT_PER_PAGE)
+    get_page(
+      '/tickets',
+      query: {
+        page: page,
+        per_page: per_page,
+        updated_since: EARLIEST_TICKET_TIMESTAMP
+      }
+    )
+  end
+
+  def retrieve_ticket(id)
+    get("/tickets/#{id}", query: { include: 'requester' })
+  end
+
+  def list_conversations(ticket_id, page: 1, per_page: DEFAULT_PER_PAGE)
+    get_page("/tickets/#{ticket_id}/conversations", query: { page: page, per_page: per_page })
+  end
+
+  private
+
+  def get_page(path, query: {})
+    response = request(path, query: query)
+    Page.new(
+      data: parsed_body(response),
+      next_page: next_page(response.headers['link'], current_page: query[:page] || query['page'])
+    )
+  end
+
+  def get(path, query: {})
+    parsed_body(request(path, query: query))
+  end
+
+  def request(path, query: {})
+    response =
+      begin
+        HTTParty.get(
+          "https://#{@domain}/api/v2#{path}",
+          query: query,
+          basic_auth: { username: @api_key, password: 'X' },
+          headers: { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+          timeout: 30
+        )
+      rescue StandardError => e
+        raise Error.new(
+          "Freshdesk API request failed before receiving a response: #{e.message}",
+          body: { transport_error_class: e.class.name }
+        )
+      end
+
+    parse_response(response)
+    response
+  end
+
+  def parse_response(response)
+    return if response.success?
+
+    body = parsed_body(response)
+    message = error_message(body, response)
+    case response.code
+    when 401, 403
+      raise AuthenticationError.new(message, status: response.code, body: body)
+    when 429
+      raise RateLimitError.new(message, status: response.code, body: body, retry_after: response.headers['retry-after'])
+    else
+      raise Error.new(message, status: response.code, body: body)
+    end
+  end
+
+  def parsed_body(response)
+    response.parsed_response.presence || (response.code == 204 ? {} : [])
+  rescue JSON::ParserError
+    {}
+  end
+
+  def error_message(body, response)
+    description = body['description'] if body.is_a?(Hash)
+    errors = body['errors'] if body.is_a?(Hash)
+    first_error = errors.first if errors.is_a?(Array)
+    first_error_message = first_error['message'] if first_error.is_a?(Hash)
+    first_error_message.presence || description.presence || "Freshdesk API request failed with status #{response.code}"
+  end
+
+  def next_page(link_header, current_page:)
+    next_link = link_header.to_s.split(',').find { |link| link.include?('rel="next"') }
+    return if next_link.blank?
+
+    url = next_link[/<([^>]+)>/, 1]
+    return if url.blank?
+
+    parse_next_page(url, current_page)
+  rescue ArgumentError, URI::InvalidURIError
+    nil
+  end
+
+  def parse_next_page(url, current_page)
+    uri = URI.parse(url)
+    page = URI.decode_www_form(uri.query.to_s).to_h['page']
+    same_domain = uri.host.blank? || uri.host.casecmp?(@domain)
+    positive_page = page&.match?(/\A[1-9]\d*\z/)
+    page.to_i if same_domain && positive_page && page.to_i > current_page.to_i
+  end
+end
diff --git a/app/services/data_imports/freshdesk/credentials_validator.rb b/app/services/data_imports/freshdesk/credentials_validator.rb
new file mode 100644
index 000000000..890b3dc30
--- /dev/null
+++ b/app/services/data_imports/freshdesk/credentials_validator.rb
@@ -0,0 +1,31 @@
+class DataImports::Freshdesk::CredentialsValidator
+  def initialize(domain:, api_key:, import_types:)
+    @domain = domain
+    @api_key = api_key.to_s.strip
+    @import_types = Array(import_types).compact_blank
+  end
+
+  def perform
+    validate_parameters!
+    client.list_contacts(per_page: 1) if @import_types.include?('contacts')
+    client.list_tickets(per_page: 1) if @import_types.include?('conversations')
+    {}
+  end
+
+  private
+
+  def validate_parameters!
+    raise ArgumentError, 'Freshdesk domain is required.' if @domain.blank?
+    raise ArgumentError, 'Freshdesk API key is required.' if @api_key.blank?
+    raise ArgumentError, 'Select at least one data type to import.' if @import_types.blank?
+
+    invalid_types = @import_types - DataImport::IMPORT_TYPES
+    raise ArgumentError, "Unsupported import types: #{invalid_types.join(', ')}" if invalid_types.present?
+
+    DataImports::Freshdesk::Client.normalize_domain(@domain)
+  end
+
+  def client
+    @client ||= DataImports::Freshdesk::Client.new(domain: @domain, api_key: @api_key)
+  end
+end
diff --git a/app/services/data_imports/freshdesk/importer.rb b/app/services/data_imports/freshdesk/importer.rb
new file mode 100644
index 000000000..04fc29d16
--- /dev/null
+++ b/app/services/data_imports/freshdesk/importer.rb
@@ -0,0 +1,59 @@
+class DataImports::Freshdesk::Importer < DataImports::Importer
+  InvalidMessagePayloadError = DataImports::Importer::InvalidMessagePayloadError
+  ALREADY_IMPORTED_ERROR_CODE = DataImports::Freshdesk::Source::ALREADY_IMPORTED_ERROR_CODE
+  SKIPPED_MESSAGE_ERROR_CODE = DataImports::Freshdesk::Source::SKIPPED_MESSAGE_ERROR_CODE
+  TRUNCATED_PARTS_ERROR_CODE = DataImports::Freshdesk::Source::TRUNCATED_PARTS_ERROR_CODE
+
+  def import_conversations_page(starting_after: cursor_for('conversations'))
+    response = conversations_page(starting_after)
+    return PageResult.new(next_cursor: cursor_for('conversations')) unless checkpoint_ticket_page(response)
+
+    update_stat_total('conversations', response['total_count']) if response['total_count'].present?
+    return PageResult.new(next_cursor: cursor_for('conversations')) unless import_conversation_summaries(response)
+    return PageResult.new(next_cursor: nil) if import_stopped?
+
+    reconcile_dirty_stats
+    verify_ticket_history_complete!(response)
+    next_cursor = response.dig('pages', 'next', 'starting_after')
+    next_cursor = update_cursor('conversations', next_cursor)
+    PageResult.new(next_cursor: next_cursor)
+  end
+
+  private
+
+  def checkpoint_ticket_page(response)
+    current_cursor = response.dig('pages', 'current', 'starting_after')
+    return true if current_cursor == cursor_for('conversations')
+
+    update_cursor('conversations', current_cursor) == current_cursor
+  end
+
+  def conversations_page(starting_after)
+    @source.list_conversations(
+      starting_after: cursor_for('conversations').presence || starting_after,
+      per_page: @source.conversations_per_page
+    )
+  end
+
+  def verify_ticket_history_complete!(response)
+    raise CustomExceptions::DataImport::FreshdeskTicketLimitError if response.dig('pages', 'limit_reached')
+  end
+
+  def import_conversation_summaries(response)
+    summaries = Array(response['data'] || response['conversations'])
+    checkpoints = Array(response.dig('pages', 'checkpoints'))
+
+    summaries.each_with_index do |conversation_summary, index|
+      break if import_stopped?
+
+      import_conversation_from_summary(conversation_summary)
+      break if import_stopped?
+
+      next if index == summaries.length - 1
+
+      checkpoint = checkpoints.fetch(index)
+      return false unless update_cursor('conversations', checkpoint) == checkpoint
+    end
+    true
+  end
+end
diff --git a/app/services/data_imports/freshdesk/message_batch_builder.rb b/app/services/data_imports/freshdesk/message_batch_builder.rb
new file mode 100644
index 000000000..0721499b6
--- /dev/null
+++ b/app/services/data_imports/freshdesk/message_batch_builder.rb
@@ -0,0 +1,10 @@
+class DataImports::Freshdesk::MessageBatchBuilder < DataImports::MessageBatchBuilder
+  def initialize(data_import:, conversation:, source_conversation:)
+    super(
+      data_import: data_import,
+      conversation: conversation,
+      source_conversation: source_conversation,
+      provider: 'freshdesk'
+    )
+  end
+end
diff --git a/app/services/data_imports/freshdesk/metadata.rb b/app/services/data_imports/freshdesk/metadata.rb
new file mode 100644
index 000000000..0351da179
--- /dev/null
+++ b/app/services/data_imports/freshdesk/metadata.rb
@@ -0,0 +1,51 @@
+class DataImports::Freshdesk::Metadata
+  def contact_custom_attributes(contact)
+    {
+      freshdesk_contact_id: contact['id'],
+      freshdesk_unique_external_id: contact['external_id']
+    }.compact
+  end
+
+  def contact_source(contact)
+    {
+      contact_id: contact['id'],
+      unique_external_id: contact['external_id'],
+      raw_phone: contact['phone'],
+      other_emails: contact['other_emails'],
+      custom_fields: contact['custom_fields'],
+      tags: contact['tags']
+    }.compact
+  end
+
+  def conversation_source(conversation)
+    {
+      ticket_id: conversation['id'],
+      subject: conversation['subject'],
+      status: conversation['status'],
+      priority: conversation['priority'],
+      requester_id: conversation['requester_id'],
+      responder_id: conversation['responder_id'],
+      group_id: conversation['group_id'],
+      company_id: conversation['company_id'],
+      tags: conversation['tags'],
+      custom_fields: conversation['custom_fields'],
+      archived: conversation['archived']
+    }.compact
+  end
+
+  def message_source(part)
+    {
+      conversation_id: part['id'],
+      conversation_source: part['source'],
+      user_id: part.dig('author', 'id'),
+      incoming: part['incoming'],
+      private: part['private'],
+      from_email: part['from_email'],
+      to_emails: part['to_emails'],
+      cc_emails: part['cc_emails'],
+      bcc_emails: part['bcc_emails'],
+      attachments: part['attachments'],
+      deleted: part['deleted']
+    }.compact
+  end
+end
diff --git a/app/services/data_imports/freshdesk/normalizer.rb b/app/services/data_imports/freshdesk/normalizer.rb
new file mode 100644
index 000000000..e277e65e2
--- /dev/null
+++ b/app/services/data_imports/freshdesk/normalizer.rb
@@ -0,0 +1,138 @@
+class DataImports::Freshdesk::Normalizer
+  WEB_CHAT_SOURCE = 15
+
+  def contact(contact)
+    {
+      'id' => contact['id']&.to_s,
+      'name' => contact['name'],
+      'email' => contact['email'],
+      'phone' => contact['mobile'].presence || contact['phone'],
+      'external_id' => contact['unique_external_id'].presence || contact['external_id'],
+      'created_at' => unix_timestamp(contact['created_at']),
+      'updated_at' => unix_timestamp(contact['updated_at']),
+      'last_seen_at' => unix_timestamp(contact['updated_at']),
+      'other_emails' => contact['other_emails'],
+      'custom_fields' => contact['custom_fields'].presence || contact['custom_field'],
+      'tags' => contact['tags']
+    }.compact
+  end
+
+  def ticket(ticket, conversations)
+    {
+      'id' => ticket['id'].to_s,
+      'created_at' => unix_timestamp(ticket['created_at']),
+      'updated_at' => unix_timestamp(ticket['updated_at']),
+      'source' => ticket_source(ticket),
+      'contacts' => { 'contacts' => conversation_contacts(ticket, conversations) },
+      'conversation_parts' => conversation_parts(conversations)
+    }.merge(ticket_metadata(ticket)).compact
+  end
+
+  private
+
+  def ticket_source(ticket)
+    source = {
+      'id' => ticket['id'].to_s,
+      'type' => DataImports::Freshdesk::SourceBucket.source_type(ticket['source']),
+      'subject' => ticket['subject'],
+      'body' => ticket['description'].presence || ticket['description_text'],
+      'attachments' => ticket['attachments'],
+      'author' => source_author(ticket)
+    }.compact
+
+    source.except!('subject', 'body') if ticket['source'].to_i == WEB_CHAT_SOURCE
+    source
+  end
+
+  def source_author(ticket)
+    requester(ticket).merge('type' => outgoing_source?(ticket) ? 'admin' : 'contact')
+  end
+
+  def outgoing_source?(ticket)
+    [10, 14].include?(ticket['source'].to_i)
+  end
+
+  def requester(ticket)
+    requester = ticket['requester'].is_a?(Hash) ? ticket['requester'] : {}
+    contact(requester.merge('id' => requester['id'] || ticket['requester_id']))
+  end
+
+  def conversation_parts(conversations)
+    sorted_conversations = conversations.each_with_index.sort_by do |conversation, index|
+      [conversation['created_at'].to_s, index]
+    end.map(&:first)
+    {
+      'conversation_parts' => sorted_conversations.map { |conversation| message(conversation) },
+      'total_count' => conversations.size
+    }
+  end
+
+  def conversation_contacts(ticket, conversations)
+    contacts = [requester(ticket)]
+    contacts.concat(conversations.filter_map { |conversation| conversation_contact(conversation) })
+    contacts.uniq { |contact_payload| contact_payload['id'].presence || contact_payload['email'].to_s.downcase.presence }
+  end
+
+  def conversation_contact(conversation)
+    return unless conversation['incoming']
+    return if conversation['user_id'].blank? && conversation['from_email'].blank?
+
+    {
+      'id' => conversation['user_id']&.to_s,
+      'name' => conversation['from_email'],
+      'email' => conversation['from_email']
+    }.compact
+  end
+
+  def ticket_metadata(ticket)
+    {
+      'subject' => ticket['subject'],
+      'status' => ticket['status'],
+      'priority' => ticket['priority'],
+      'requester_id' => ticket['requester_id'],
+      'responder_id' => ticket['responder_id'],
+      'group_id' => ticket['group_id'],
+      'company_id' => ticket['company_id'],
+      'tags' => ticket['tags'],
+      'custom_fields' => ticket['custom_fields'],
+      'archived' => ticket['archived']
+    }
+  end
+
+  def message(conversation)
+    message_attributes(conversation).merge(message_metadata(conversation)).compact
+  end
+
+  def message_attributes(conversation)
+    {
+      'id' => conversation['id'].to_s,
+      'part_type' => conversation['private'] ? 'note' : 'comment',
+      'body' => conversation['body'].presence || conversation['body_text'],
+      'attachments' => conversation['attachments'],
+      'created_at' => unix_timestamp(conversation['created_at']),
+      'updated_at' => unix_timestamp(conversation['updated_at']),
+      'author' => message_author(conversation)
+    }
+  end
+
+  def message_metadata(conversation)
+    conversation.slice(
+      'source', 'incoming', 'private', 'from_email', 'to_emails', 'cc_emails', 'bcc_emails', 'deleted'
+    )
+  end
+
+  def message_author(conversation)
+    {
+      'id' => conversation['user_id']&.to_s,
+      'type' => conversation['incoming'] ? 'contact' : 'admin',
+      'name' => conversation['from_email'],
+      'email' => conversation['from_email']
+    }.compact
+  end
+
+  def unix_timestamp(value)
+    return if value.blank?
+
+    Time.zone.parse(value.to_s).to_i
+  end
+end
diff --git a/app/services/data_imports/freshdesk/placeholder_inbox_builder.rb b/app/services/data_imports/freshdesk/placeholder_inbox_builder.rb
new file mode 100644
index 000000000..cc38f67be
--- /dev/null
+++ b/app/services/data_imports/freshdesk/placeholder_inbox_builder.rb
@@ -0,0 +1,5 @@
+class DataImports::Freshdesk::PlaceholderInboxBuilder < DataImports::PlaceholderInboxBuilder
+  def initialize(account:)
+    super(account: account, provider: 'freshdesk', source_bucket: DataImports::Freshdesk::SourceBucket)
+  end
+end
diff --git a/app/services/data_imports/freshdesk/source.rb b/app/services/data_imports/freshdesk/source.rb
new file mode 100644
index 000000000..d2ed82caa
--- /dev/null
+++ b/app/services/data_imports/freshdesk/source.rb
@@ -0,0 +1,196 @@
+class DataImports::Freshdesk::Source
+  PROVIDER = 'freshdesk'.freeze
+  DISPLAY_NAME = 'Freshdesk'.freeze
+  CONTACTS_PER_PAGE = 100
+  CONVERSATIONS_PER_PAGE = 100
+  ALREADY_IMPORTED_ERROR_CODE = 'DataImports::Freshdesk::AlreadyImported'.freeze
+  SKIPPED_MESSAGE_ERROR_CODE = 'DataImports::Freshdesk::SkippedMessage'.freeze
+  TRUNCATED_PARTS_ERROR_CODE = 'DataImports::Freshdesk::TruncatedConversations'.freeze
+
+  attr_reader :provider, :display_name, :contacts_per_page, :conversations_per_page
+
+  def self.credentials_validator(source_params:, import_types:)
+    DataImports::Freshdesk::CredentialsValidator.new(
+      domain: source_params[:domain],
+      api_key: source_params[:access_token],
+      import_types: import_types
+    )
+  end
+
+  def self.source_metadata(source_params)
+    { domain: DataImports::Freshdesk::Client.normalize_domain(source_params[:domain]) }
+  end
+
+  def self.default_import_name
+    'Freshdesk import'
+  end
+
+  def self.credential_name
+    'API key'
+  end
+
+  def self.import_job_class
+    DataImports::Freshdesk::ImportJob
+  end
+
+  def self.importer_class
+    DataImports::Freshdesk::Importer
+  end
+
+  def self.contacts_page_job_class
+    DataImports::Freshdesk::ContactsPageJob
+  end
+
+  def self.conversations_page_job_class
+    DataImports::Freshdesk::ConversationsPageJob
+  end
+
+  def self.client_error?(error)
+    error.is_a?(DataImports::Freshdesk::Client::Error)
+  end
+
+  def self.authentication_error?(error)
+    error.is_a?(DataImports::Freshdesk::Client::AuthenticationError)
+  end
+
+  def initialize(access_token:, source_metadata: {})
+    @provider = PROVIDER
+    @display_name = DISPLAY_NAME
+    @contacts_per_page = CONTACTS_PER_PAGE
+    @conversations_per_page = CONVERSATIONS_PER_PAGE
+    @client = DataImports::Freshdesk::Client.new(domain: source_metadata['domain'] || source_metadata[:domain], api_key: access_token)
+    @normalizer = DataImports::Freshdesk::Normalizer.new
+    @metadata = DataImports::Freshdesk::Metadata.new
+  end
+
+  def list_contacts(starting_after:, per_page:)
+    page = @client.list_contacts(page: starting_after.presence || 1, per_page: per_page)
+    paginated_response(page, Array(page.data).map { |contact| @normalizer.contact(contact) })
+  end
+
+  def list_conversations(starting_after:, per_page:)
+    page = DataImports::Freshdesk::TicketPage.new(client: @client, starting_after: starting_after, per_page: per_page)
+    summaries = page.chunk.map do |ticket|
+      {
+        'id' => ticket['id'].to_s,
+        'source' => { 'type' => DataImports::Freshdesk::SourceBucket.source_type(ticket['source']) }
+      }
+    end
+    {
+      'data' => summaries,
+      'pages' => {
+        'current' => { 'starting_after' => page.current_cursor },
+        'next' => page.next_cursor.present? ? { 'starting_after' => page.next_cursor } : nil,
+        'checkpoints' => page.checkpoints,
+        'limit_reached' => page.limit_reached?
+      }
+    }
+  end
+
+  def retrieve_conversation(id)
+    ticket = @client.retrieve_ticket(id)
+    conversations = all_conversations(id)
+    @normalizer.ticket(ticket, conversations)
+  end
+
+  def retrieve_contact(id)
+    @normalizer.contact(@client.retrieve_contact(id))
+  end
+
+  def client_error?(error)
+    error.is_a?(DataImports::Freshdesk::Client::Error)
+  end
+
+  def placeholder_inbox_builder(account:)
+    DataImports::Freshdesk::PlaceholderInboxBuilder.new(account: account)
+  end
+
+  def message_batch_builder(data_import:, conversation:, source_conversation:)
+    DataImports::Freshdesk::MessageBatchBuilder.new(
+      data_import: data_import,
+      conversation: conversation,
+      source_conversation: source_conversation
+    )
+  end
+
+  def activity_part?(_part)
+    false
+  end
+
+  def source_message_importable?(source)
+    DataImports::Freshdesk::MessageBatchBuilder.source_message_importable?(source)
+  end
+
+  def activity_content(_part)
+    nil
+  end
+
+  def already_imported_error_code
+    ALREADY_IMPORTED_ERROR_CODE
+  end
+
+  def skipped_message_error_code
+    SKIPPED_MESSAGE_ERROR_CODE
+  end
+
+  def truncated_parts_error_code
+    TRUNCATED_PARTS_ERROR_CODE
+  end
+
+  def skipped_message_reason
+    'blank_freshdesk_conversation'
+  end
+
+  def contact_custom_attributes(contact_payload)
+    @metadata.contact_custom_attributes(contact_payload)
+  end
+
+  def contact_source_metadata(contact_payload)
+    @metadata.contact_source(contact_payload)
+  end
+
+  def conversation_custom_attributes(conversation)
+    {
+      freshdesk_ticket_id: conversation['id'],
+      freshdesk_subject: conversation['subject'],
+      freshdesk_status: conversation['status'],
+      freshdesk_priority: conversation['priority']
+    }.compact
+  end
+
+  def conversation_source_metadata(conversation)
+    @metadata.conversation_source(conversation)
+  end
+
+  def message_source_metadata(part)
+    @metadata.message_source(part)
+  end
+
+  def timestamp_for(value)
+    return Time.current if value.blank?
+
+    value.is_a?(Numeric) || value.to_s.match?(/\A-?\d+(?:\.\d+)?\z/) ? Time.zone.at(value.to_f) : Time.zone.parse(value.to_s)
+  end
+
+  private
+
+  def paginated_response(page, records)
+    {
+      'data' => records,
+      'pages' => { 'next' => page.next_page.present? ? { 'starting_after' => page.next_page } : nil }
+    }
+  end
+
+  def all_conversations(ticket_id)
+    records = []
+    page_number = 1
+    loop do
+      page = @client.list_conversations(ticket_id, page: page_number, per_page: CONVERSATIONS_PER_PAGE)
+      records.concat(Array(page.data))
+      break if page.next_page.blank?
+
+      page_number = page.next_page
+    end
+    records
+  end
+end
diff --git a/app/services/data_imports/freshdesk/source_bucket.rb b/app/services/data_imports/freshdesk/source_bucket.rb
new file mode 100644
index 000000000..4b6a193cd
--- /dev/null
+++ b/app/services/data_imports/freshdesk/source_bucket.rb
@@ -0,0 +1,61 @@
+class DataImports::Freshdesk::SourceBucket
+  SOURCE_TYPES = {
+    1 => 'email',
+    2 => 'portal',
+    3 => 'phone',
+    4 => 'forum',
+    5 => 'twitter',
+    6 => 'facebook',
+    7 => 'chat',
+    8 => 'mobihelp',
+    9 => 'feedback_widget',
+    10 => 'outbound_email',
+    11 => 'ecommerce',
+    12 => 'bot',
+    13 => 'whatsapp',
+    14 => 'chat_internal_task',
+    15 => 'web_chat',
+    16 => 'web_form',
+    17 => 'instagram_message',
+    18 => 'instagram_comment',
+    19 => 'facebook_message',
+    20 => 'facebook_comment',
+    21 => 'mobile_chat_sdk',
+    22 => 'sms'
+  }.freeze
+
+  BUCKETS = {
+    'email' => { key: 'email', name: 'Email' },
+    'outbound_email' => { key: 'email', name: 'Email' },
+    'phone' => { key: 'phone', name: 'Phone' },
+    'forum' => { key: 'forum', name: 'Forum' },
+    'twitter' => { key: 'twitter', name: 'Twitter' },
+    'facebook' => { key: 'facebook', name: 'Facebook' },
+    'portal' => { key: 'portal', name: 'Portal' },
+    'feedback_widget' => { key: 'portal', name: 'Portal' },
+    'chat' => { key: 'chat', name: 'Chat' },
+    'mobihelp' => { key: 'mobile', name: 'Mobile' },
+    'ecommerce' => { key: 'ecommerce', name: 'Ecommerce' },
+    'bot' => { key: 'bot', name: 'Bot' },
+    'whatsapp' => { key: 'whatsapp', name: 'WhatsApp' },
+    'chat_internal_task' => { key: 'internal_task', name: 'Internal task' },
+    'web_chat' => { key: 'chat', name: 'Chat' },
+    'web_form' => { key: 'portal', name: 'Portal' },
+    'instagram_message' => { key: 'instagram', name: 'Instagram' },
+    'instagram_comment' => { key: 'instagram', name: 'Instagram' },
+    'facebook_message' => { key: 'facebook', name: 'Facebook' },
+    'facebook_comment' => { key: 'facebook', name: 'Facebook' },
+    'mobile_chat_sdk' => { key: 'mobile', name: 'Mobile' },
+    'sms' => { key: 'sms', name: 'SMS' }
+  }.freeze
+
+  DEFAULT_BUCKET = { key: 'unknown', name: 'Unknown' }.freeze
+
+  def self.source_type(value)
+    SOURCE_TYPES[value.to_i] || 'unknown'
+  end
+
+  def self.for(source_type)
+    BUCKETS[source_type.to_s.downcase] || DEFAULT_BUCKET
+  end
+end
diff --git a/app/services/data_imports/freshdesk/ticket_page.rb b/app/services/data_imports/freshdesk/ticket_page.rb
new file mode 100644
index 000000000..37eb0bba6
--- /dev/null
+++ b/app/services/data_imports/freshdesk/ticket_page.rb
@@ -0,0 +1,62 @@
+class DataImports::Freshdesk::TicketPage
+  TICKETS_PER_CHUNK = 10
+
+  attr_reader :current_cursor
+
+  def initialize(client:, starting_after:, per_page:)
+    @client = client
+    @per_page = per_page
+    @cursor = normalize_cursor(starting_after)
+    @tickets, next_page = ticket_page(per_page)
+    @page_limit_reached = page_limit_reached?
+    next_page = nil if @page_limit_reached
+    @current_cursor = @cursor.merge('tickets' => @tickets, 'next_page' => next_page)
+  end
+
+  def chunk
+    @chunk ||= @tickets.slice(@cursor['offset'], TICKETS_PER_CHUNK) || []
+  end
+
+  def checkpoints
+    @checkpoints ||= chunk.each_index.map { |index| cursor_after(index + 1) }
+  end
+
+  def next_cursor
+    return checkpoints.last if chunk.present?
+
+    cursor_after(0)
+  end
+
+  def limit_reached?
+    @page_limit_reached && next_cursor.nil?
+  end
+
+  private
+
+  def normalize_cursor(starting_after)
+    return { 'page' => starting_after.presence || 1, 'offset' => 0 } unless starting_after.is_a?(Hash)
+
+    cursor = starting_after.deep_stringify_keys.slice('page', 'offset', 'tickets', 'next_page')
+    cursor.merge('page' => cursor['page'] || 1, 'offset' => cursor['offset'].to_i)
+  end
+
+  def ticket_page(per_page)
+    return [Array(@cursor['tickets']), @cursor['next_page']] if @cursor.key?('tickets')
+
+    page = @client.list_tickets(page: @cursor['page'], per_page: per_page)
+    tickets = Array(page.data).map { |ticket| ticket.slice('id', 'source') }
+    [tickets, page.next_page]
+  end
+
+  def cursor_after(processed_count)
+    next_offset = @cursor['offset'] + processed_count
+    return current_cursor.merge('offset' => next_offset) if next_offset < @tickets.size
+    return { 'page' => current_cursor['next_page'], 'offset' => 0 } if current_cursor['next_page'].present?
+
+    nil
+  end
+
+  def page_limit_reached?
+    @cursor['page'].to_i >= DataImports::Freshdesk::Client::MAX_TICKET_PAGES && @tickets.size >= @per_page
+  end
+end
diff --git a/app/services/data_imports/importer.rb b/app/services/data_imports/importer.rb
new file mode 100644
index 000000000..7c9076cdd
--- /dev/null
+++ b/app/services/data_imports/importer.rb
@@ -0,0 +1,1350 @@
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Rails/SkipsModelValidations
+class DataImports::Importer
+  class InvalidMessagePayloadError < StandardError; end
+
+  PageResult = Struct.new(:next_cursor, keyword_init: true) do
+    def done?
+      next_cursor.blank?
+    end
+  end
+
+  DEFAULT_IMPORT_TYPES = %w[contacts conversations].freeze
+  MESSAGES_PER_BATCH = 100
+  HEARTBEAT_INTERVAL = 1.minute
+  QUERY_TIMEOUT_RETRY_LIMIT = 1
+  QUERY_TIMEOUT_RETRY_DELAY_RANGE = (0.2..0.5)
+  MESSAGE_MAPPING_UNIQUE_INDEX = :idx_data_import_mappings_on_account_and_source
+  E164_REGEX = /\A\+[1-9]\d{1,14}\z/
+  PHONE_WITHOUT_PLUS_REGEX = /\A[1-9]\d{1,14}\z/
+
+  MessageBatchResult = Struct.new(
+    :imported_entries,
+    :skipped_entries,
+    :current_entries,
+    :previous_entries,
+    :messages,
+    :failed_entries,
+    keyword_init: true
+  )
+
+  def initialize(data_import:, run_id: nil, source: nil)
+    @data_import = data_import
+    @run_id = run_id
+    @account = data_import.account
+    @source = source || DataImports::Source.for(data_import)
+    @placeholder_inboxes = @source.placeholder_inbox_builder(account: @account)
+    @stats = default_stats.deep_merge(data_import.stats || {})
+    @persisted_cursor = data_import.cursor.to_h.deep_stringify_keys
+    @persisted_stats = @stats.deep_dup
+    @dirty_stat_groups = {}
+  end
+
+  def perform
+    return unless start!
+
+    import_contacts if import_type?('contacts')
+    import_conversations if import_type?('conversations')
+    finish!
+  rescue StandardError => e
+    fail!(e)
+    raise
+  end
+
+  def start!
+    return if @data_import.reload.abandoned?
+
+    @data_import.update!(status: :processing, started_at: @data_import.started_at || Time.current)
+  end
+
+  def finish!
+    @data_import.with_lock do
+      next if @data_import.abandoned? || stale_import_run?
+
+      error_count = @data_import.import_errors.non_skip_logs.count + @data_import.import_errors.failed.count
+      @stats['errors']['count'] = error_count
+      status = error_count.positive? ? :completed_with_errors : :completed
+      @data_import.update!(
+        status: status,
+        completed_at: Time.current,
+        stats: @stats,
+        total_records: total_processed_records,
+        processed_records: total_successful_records
+      )
+    end
+  end
+
+  def fail!(error)
+    @data_import.with_lock do
+      next if @data_import.abandoned? || stale_import_run?
+
+      record_run_error(error)
+      @data_import.update!(status: :failed, last_error_at: Time.current)
+    end
+  end
+
+  def import_contacts_page(starting_after: cursor_for('contacts'))
+    response = @source.list_contacts(starting_after: starting_after, per_page: @source.contacts_per_page)
+    update_stat_total('contacts', response['total_count']) if response['total_count'].present?
+    Array(response['data'] || response['contacts']).each do |contact|
+      break if import_stopped?
+
+      import_contact(contact)
+    end
+    return PageResult.new(next_cursor: nil) if import_stopped?
+
+    reconcile_dirty_stats
+    next_cursor = response.dig('pages', 'next', 'starting_after')
+    next_cursor = update_cursor('contacts', next_cursor)
+    PageResult.new(next_cursor: next_cursor)
+  end
+
+  def import_conversations_page(starting_after: cursor_for('conversations'))
+    response = @source.list_conversations(starting_after: starting_after, per_page: @source.conversations_per_page)
+    update_stat_total('conversations', response['total_count']) if response['total_count'].present?
+    Array(response['data'] || response['conversations']).each do |conversation_summary|
+      break if import_stopped?
+
+      import_conversation_from_summary(conversation_summary)
+    end
+    return PageResult.new(next_cursor: nil) if import_stopped?
+
+    reconcile_dirty_stats
+    next_cursor = response.dig('pages', 'next', 'starting_after')
+    next_cursor = update_cursor('conversations', next_cursor)
+    PageResult.new(next_cursor: next_cursor)
+  end
+
+  def import_contacts?
+    import_type?('contacts')
+  end
+
+  def import_conversations?
+    import_type?('conversations')
+  end
+
+  def contacts_completed?
+    stage_completed?('contacts')
+  end
+
+  def conversations_completed?
+    stage_completed?('conversations')
+  end
+
+  def cursor_for(key)
+    @data_import.cursor&.dig(key, 'starting_after')
+  end
+
+  private
+
+  def import_contacts
+    cursor = cursor_for('contacts')
+    loop do
+      result = import_contacts_page(starting_after: cursor)
+      break if result.done?
+
+      cursor = result.next_cursor
+    end
+  end
+
+  def import_conversations
+    cursor = cursor_for('conversations')
+    loop do
+      result = import_conversations_page(starting_after: cursor)
+      break if result.done?
+
+      cursor = result.next_cursor
+    end
+  end
+
+  def import_conversation_from_summary(conversation_summary)
+    source_id = source_id_for(conversation_summary)
+    item, already_handled = prepare_import_item('conversation', source_id, conversation_summary)
+    conversation = @source.retrieve_conversation(source_id)
+    return if import_stopped?
+
+    with_import_item_lock(item, already_handled: already_handled) do |locked_item, item_already_handled|
+      import_conversation_item(locked_item, conversation_summary, conversation, source_id, item_already_handled)
+    end
+  rescue StandardError => e
+    raise if @source.client_error?(e)
+
+    fail_item(item, e)
+  ensure
+    persist_stats unless @import_stopped
+  end
+
+  def import_conversation_item(item, conversation_summary, conversation, source_id, already_handled)
+    mapping = find_mapping('conversation', source_id)
+    update_message_total(item, conversation)
+
+    contact_payloads = conversation_contacts(conversation)
+    contact = import_contact(contact_payloads.first, required_for_conversation: true)
+    contact_payloads.drop(1).each { |contact_payload| import_contact(contact_payload) }
+    source_type = conversation_source_type(conversation, conversation_summary)
+    inbox = @placeholder_inboxes.inbox_for(source_type)
+    contact_inbox = contact_inbox_for(contact, inbox)
+
+    mapped_conversation = mapping&.chatwoot_record
+    if mapped_conversation && mapping.data_import_id != @data_import.id
+      skip_already_imported_item(item, mapping, already_handled: already_handled)
+      reconcile_item_stats('conversation') if already_handled
+      return unless import_conversation_messages(conversation, mapped_conversation, contact)
+
+      update_conversation_activity(mapped_conversation)
+      return
+    end
+
+    chatwoot_conversation = mapped_conversation || create_conversation(conversation, contact, contact_inbox, inbox, source_type)
+    if mapped_conversation
+      record_mapping('conversation', source_id, chatwoot_conversation, metadata: conversation_metadata(conversation, inbox, source_type))
+    end
+    item.update!(status: :imported, chatwoot_record_type: 'Conversation', chatwoot_record_id: chatwoot_conversation.id)
+    if already_handled
+      reconcile_item_stats('conversation')
+    else
+      increment_stat('conversations', 'imported')
+    end
+
+    return unless import_conversation_messages(conversation, chatwoot_conversation, contact)
+
+    update_conversation_activity(chatwoot_conversation)
+  end
+
+  def import_stopped?
+    return true if @import_stopped
+
+    @data_import.reload
+    @import_stopped = @data_import.abandoned? || @data_import.completed? || @data_import.completed_with_errors? || stale_import_run?
+  end
+
+  def continue_import_with_heartbeat?
+    return false if import_stopped?
+    return true if @data_import.updated_at > HEARTBEAT_INTERVAL.ago
+
+    @data_import.touch if @data_import.updated_at <= HEARTBEAT_INTERVAL.ago
+    true
+  end
+
+  def stale_import_run?
+    active_run_id = @data_import.active_import_run_id
+    @run_id.present? && active_run_id.present? && active_run_id != @run_id
+  end
+
+  def import_contact(contact_payload, required_for_conversation: false)
+    item = nil
+    with_query_timeout_retry do
+      source_id = source_id_for(contact_payload)
+      mapping = find_mapping('contact', source_id) if source_id.present?
+      contact_payload = retrieve_contact_payload(contact_payload) unless mapping&.chatwoot_record
+      source_id = source_id_for(contact_payload)
+      item, already_handled = prepare_import_item('contact', source_id, contact_payload)
+
+      with_import_item_lock(item, already_handled: already_handled) do |locked_item, item_already_handled|
+        import_contact_item(locked_item, contact_payload, source_id, item_already_handled)
+      end
+    end
+  rescue StandardError => e
+    raise if @source.client_error?(e)
+
+    fail_item(item, e)
+    raise if required_for_conversation
+  ensure
+    persist_stats
+  end
+
+  def import_contact_item(item, contact_payload, source_id, already_handled)
+    mapping = find_mapping('contact', source_id)
+    mapped_contact = mapping&.chatwoot_record
+    return reuse_mapped_contact(item, mapping, mapped_contact, already_handled: already_handled) if mapped_contact
+
+    contact = Contact.transaction do
+      imported_contact = find_existing_contact(contact_payload) || create_contact(contact_payload)
+      update_existing_contact(imported_contact, contact_payload)
+      record_mapping('contact', source_id, imported_contact, metadata: contact_metadata(contact_payload))
+      item.update!(status: :imported, chatwoot_record_type: 'Contact', chatwoot_record_id: imported_contact.id)
+      imported_contact
+    end
+    increment_stat('contacts', 'imported') unless already_handled
+    contact
+  end
+
+  def retrieve_contact_payload(contact_payload)
+    return contact_payload if contact_payload.blank?
+    return contact_payload if contact_payload['email'].present? || contact_payload['phone'].present? || contact_payload['name'].present?
+    return contact_payload if contact_payload['id'].blank?
+
+    @source.retrieve_contact(contact_payload['id'])
+  rescue StandardError => e
+    raise unless @source.client_error?(e)
+    raise unless e.status == 404
+
+    contact_payload
+  end
+
+  def create_contact(contact_payload)
+    attrs = contact_attributes(contact_payload).merge(created_at: timestamp_for(contact_payload['created_at']), updated_at: Time.current)
+    result = Contact.insert_all!([attrs], returning: %w[id])
+    Contact.find(result.rows.first.first)
+  rescue ActiveRecord::RecordNotUnique
+    find_existing_contact(contact_payload)
+  end
+
+  def reuse_mapped_contact(item, mapping, mapped_contact, already_handled:)
+    if mapping.data_import_id == @data_import.id
+      reconcile_current_run_contact(item, mapped_contact)
+      return mapped_contact
+    end
+
+    skip_already_imported_item(item, mapping, already_handled: already_handled)
+    mapped_contact
+  end
+
+  def update_existing_contact(contact, contact_payload)
+    attrs = contact_attributes(contact_payload)
+    updates = {}
+    updates[:name] = attrs[:name] if contact.name.blank? && attrs[:name].present?
+    updates[:email] = attrs[:email] if contact_email_available?(contact, attrs[:email])
+    updates[:phone_number] = attrs[:phone_number] if contact_phone_number_available?(contact, attrs[:phone_number])
+    updates[:identifier] = attrs[:identifier] if contact.identifier.blank? && attrs[:identifier].present?
+    updates[:last_activity_at] = attrs[:last_activity_at] if contact.last_activity_at.blank? && attrs[:last_activity_at].present?
+    updates[:additional_attributes] = contact.additional_attributes.to_h.deep_merge(attrs[:additional_attributes])
+    updates[:custom_attributes] = contact.custom_attributes.to_h.deep_merge(attrs[:custom_attributes])
+    if contact.visitor? && attrs[:contact_type].present? && contact_resolved_after_update?(contact, updates)
+      updates[:contact_type] = attrs[:contact_type]
+    end
+    updates[:updated_at] = Time.current
+    contact.update_columns(updates) if updates.present?
+    contact.reload
+  end
+
+  def contact_email_available?(contact, email)
+    return false if contact.email.present? || email.blank?
+
+    @account.contacts.where.not(id: contact.id).where('LOWER(email) = ?', email.downcase).empty?
+  end
+
+  def contact_phone_number_available?(contact, phone_number)
+    return false if contact.phone_number.present? || phone_number.blank?
+
+    @account.contacts.where.not(id: contact.id).where(phone_number: phone_number).empty?
+  end
+
+  def contact_resolved_after_update?(contact, updates)
+    contact.email.present? || contact.phone_number.present? || updates[:email].present? || updates[:phone_number].present?
+  end
+
+  def find_existing_contact(contact_payload)
+    identifier = normalized_identifier(contact_payload)
+    email = normalized_email(contact_payload)
+    phone_number = normalized_phone(contact_payload)
+
+    if identifier.present?
+      contact = @account.contacts.find_by(identifier: identifier)
+      return contact if contact.present?
+    end
+
+    if email.present?
+      contact = @account.contacts.from_email(email)
+      return contact if contact.present?
+    end
+    return @account.contacts.find_by(phone_number: phone_number) if phone_number.present?
+
+    nil
+  end
+
+  def contact_attributes(contact_payload)
+    attrs = {
+      account_id: @account.id,
+      name: contact_payload['name'].presence || contact_payload['email'].presence || '',
+      email: normalized_email(contact_payload),
+      phone_number: normalized_phone(contact_payload),
+      identifier: normalized_identifier(contact_payload),
+      last_activity_at: contact_activity_at(contact_payload),
+      additional_attributes: {
+        source: @source.contact_source_metadata(contact_payload).merge(provider: @source.provider)
+      },
+      custom_attributes: @source.contact_custom_attributes(contact_payload)
+    }
+    attrs[:contact_type] = Contact.contact_types[:lead] if attrs[:email].present? || attrs[:phone_number].present?
+    attrs
+  end
+
+  def create_conversation(conversation, contact, contact_inbox, inbox, source_type)
+    source_id = source_id_for(conversation)
+    metadata = conversation_metadata(conversation, inbox, source_type)
+    if (existing_conversation = @account.conversations.find_by(identifier: conversation_identifier(conversation)))
+      record_mapping('conversation', source_id, existing_conversation, metadata: metadata)
+      return existing_conversation
+    end
+
+    attrs = {
+      account_id: @account.id,
+      inbox_id: inbox.id,
+      status: Conversation.statuses['resolved'],
+      contact_id: contact.id,
+      contact_inbox_id: contact_inbox.id,
+      identifier: conversation_identifier(conversation),
+      additional_attributes: metadata,
+      custom_attributes: @source.conversation_custom_attributes(conversation),
+      created_at: timestamp_for(conversation['created_at']),
+      updated_at: timestamp_for(conversation['updated_at']),
+      last_activity_at: timestamp_for(conversation['updated_at'])
+    }
+
+    Conversation.transaction do
+      result = Conversation.insert_all!([attrs], returning: %w[id])
+      chatwoot_conversation = Conversation.find(result.rows.first.first)
+      record_mapping('conversation', source_id, chatwoot_conversation, metadata: metadata)
+      chatwoot_conversation
+    end
+  rescue ActiveRecord::RecordNotUnique
+    @account.conversations.find_by!(identifier: conversation_identifier(conversation)).tap do |chatwoot_conversation|
+      record_mapping('conversation', source_id, chatwoot_conversation, metadata: metadata)
+    end
+  end
+
+  def import_conversation_messages(conversation, chatwoot_conversation, contact)
+    parts_payload = conversation['conversation_parts'].to_h
+    parts = Array(parts_payload['conversation_parts'])
+    batch_builder = @source.message_batch_builder(
+      data_import: @data_import,
+      conversation: chatwoot_conversation,
+      source_conversation: conversation
+    )
+    batch = begin
+      with_query_timeout_retry { batch_builder.perform }
+    rescue ActiveRecord::QueryCanceled
+      nil
+    end
+    return import_conversation_messages_individually(conversation, chatwoot_conversation, contact, batch_builder, parts.size) if batch.nil?
+
+    record_truncated_conversation_parts(conversation, parts.size)
+
+    batch.entries.each_slice(MESSAGES_PER_BATCH) do |entries|
+      return false unless continue_import_with_heartbeat?
+
+      import_message_batch(chatwoot_conversation, contact, batch_builder, entries)
+      return false if @import_stopped
+    end
+    return false if import_stopped?
+
+    true
+  end
+
+  def import_message_batch(conversation, contact, batch_builder, entries)
+    result = bulk_message_batch_result(conversation, contact, batch_builder, entries)
+    return if result.blank?
+
+    result.current_entries.each do |entry|
+      reconcile_bulk_message_entry(conversation, entry) do
+        reconcile_current_run_message_mapping(conversation, entry.mapping, entry.part)
+      end
+    end
+    result.previous_entries.each do |entry|
+      reconcile_bulk_message_entry(conversation, entry) do
+        skip_existing_message_mapping(conversation, entry.mapping, entry.part)
+      end
+    end
+    result.skipped_entries.each do |entry|
+      reconcile_bulk_message_entry(conversation, entry) { record_bulk_skipped_message(conversation, entry) }
+    end
+    Array(result.failed_entries).each { |entry, error| fail_message(conversation, entry.source_id, entry.part, error) }
+    increment_stat('messages', 'imported', result.imported_entries.size)
+    result.messages.each { |message| reindex_message_for_search(message) }
+  end
+
+  def bulk_message_batch_result(conversation, contact, batch_builder, entries)
+    with_query_timeout_retry do
+      bulk_write_message_entries(conversation, contact, batch_builder, entries)
+    end
+  rescue ActiveRecord::ActiveRecordError
+    fallback_message_entries(conversation, contact, batch_builder, entries) unless @import_stopped
+    nil
+  end
+
+  def fallback_message_entries(conversation, contact, batch_builder, entries)
+    entries.each do |entry|
+      break unless continue_import_with_heartbeat?
+
+      message = fallback_message_entry(conversation, contact, batch_builder, entry)
+      reindex_message_for_search(message) if message.is_a?(Message)
+    end
+  end
+
+  def fallback_message_entry(conversation, contact, batch_builder, entry)
+    with_query_timeout_retry do
+      @data_import.with_lock do
+        if inactive_import_run?
+          @import_stopped = true
+          next
+        end
+
+        refreshed_entry = batch_builder.refresh([entry]).entries.first
+        import_message(conversation, contact, refreshed_entry, reindex: false)
+      end
+    end
+  rescue ActiveRecord::ActiveRecordError => e
+    fail_message(conversation, entry.source_id, entry.part, e)
+  end
+
+  def bulk_write_message_entries(conversation, contact, batch_builder, entries)
+    @data_import.with_lock do
+      if inactive_import_run?
+        @import_stopped = true
+        next
+      end
+
+      refreshed_entries = batch_builder.refresh(entries).entries
+      persist_message_entries(conversation, contact, refreshed_entries)
+    end
+  end
+
+  def inactive_import_run?
+    @data_import.abandoned? || @data_import.failed? || @data_import.completed? ||
+      @data_import.completed_with_errors? || stale_import_run?
+  end
+
+  def persist_message_entries(conversation, contact, entries)
+    grouped_entries = entries.group_by(&:classification)
+    writable_entries = entries.select do |entry|
+      %i[repairable_stale_mapping existing_message new_message].include?(entry.classification)
+    end
+    content_by_source_id = {}
+    attributes_by_source_id = {}
+    failed_entries = []
+    writable_entries.select! do |entry|
+      validate_message_payload!(entry.part)
+      content = content_for(entry.part)
+      content_by_source_id[entry.source_id] = content
+      if content.present? && entry.message.blank?
+        attributes_by_source_id[entry.source_id] = message_attributes(conversation, contact, entry.part, entry.source_id, content)
+      end
+      true
+    rescue InvalidMessagePayloadError => e
+      failed_entries << [entry, e]
+      false
+    end
+    skipped_entries, imported_entries = writable_entries.partition { |entry| content_by_source_id[entry.source_id].blank? }
+    messages = insert_messages(imported_entries, attributes_by_source_id)
+    upsert_message_mappings(conversation, imported_entries, skipped_entries, messages)
+
+    MessageBatchResult.new(
+      imported_entries: imported_entries,
+      skipped_entries: skipped_entries,
+      current_entries: grouped_entries.fetch(:current_import, []),
+      previous_entries: grouped_entries.fetch(:previous_import, []),
+      messages: messages,
+      failed_entries: failed_entries
+    )
+  end
+
+  def insert_messages(entries, attributes_by_source_id)
+    new_entries = entries.reject(&:message)
+    if new_entries.present?
+      attributes = new_entries.map { |entry| attributes_by_source_id.fetch(entry.source_id) }
+      result = Message.insert_all!(attributes, returning: %w[id source_id])
+      inserted_messages = Message.where(id: result.pluck('id')).index_by(&:source_id)
+    end
+
+    entries.map do |entry|
+      entry.message || inserted_messages.fetch("#{@source.provider}:#{entry.source_id}")
+    end
+  end
+
+  def validate_message_payload!(part)
+    raise InvalidMessagePayloadError, "#{@source.display_name} message payload must be an object" unless part.is_a?(Hash)
+
+    %w[author assigned_to event_details].each do |field|
+      value = part[field]
+      next if value.nil? || value.is_a?(Hash)
+
+      raise InvalidMessagePayloadError, "#{@source.display_name} message #{field} must be an object"
+    end
+
+    participant = part.dig('event_details', 'participant')
+    unless participant.nil? || participant.is_a?(Hash)
+      raise InvalidMessagePayloadError, "#{@source.display_name} message event_details.participant must be an object"
+    end
+
+    %w[created_at updated_at].each do |field|
+      value = part[field]
+      valid_timestamp = value.nil? || value.is_a?(Integer) || value.is_a?(Float) ||
+                        (value.is_a?(String) && (value.blank? || value.match?(/\A-?\d+(?:\.\d+)?\z/)))
+      raise InvalidMessagePayloadError, "#{@source.display_name} message #{field} must be a Unix timestamp" unless valid_timestamp
+
+      timestamp_for(value) if value.present?
+    rescue RangeError
+      raise InvalidMessagePayloadError, "#{@source.display_name} message #{field} must be a Unix timestamp"
+    end
+
+    %w[body subject].each do |field|
+      value = part[field]
+      next unless value.is_a?(String) && !value.valid_encoding?
+
+      raise InvalidMessagePayloadError, "#{@source.display_name} message #{field} must use valid encoding"
+    end
+  end
+
+  def upsert_message_mappings(conversation, imported_entries, skipped_entries, messages)
+    now = Time.current
+    mapping_attributes = imported_entries.zip(messages).map do |entry, message|
+      message_mapping_attributes(entry, 'Message', message.id, message_metadata(entry.part), now)
+    end
+    mapping_attributes.concat(skipped_entries.filter_map do |entry|
+      next if entry.mapping
+
+      metadata = message_metadata(entry.part).merge(skipped: true, reason: @source.skipped_message_reason)
+      message_mapping_attributes(entry, 'Conversation', conversation.id, metadata, now)
+    end)
+    return if mapping_attributes.empty?
+
+    DataImportMapping.upsert_all(
+      mapping_attributes,
+      unique_by: MESSAGE_MAPPING_UNIQUE_INDEX,
+      update_only: %i[data_import_id chatwoot_record_type chatwoot_record_id metadata updated_at],
+      record_timestamps: false
+    )
+  end
+
+  def message_mapping_attributes(entry, record_type, record_id, metadata, now)
+    {
+      account_id: @account.id,
+      data_import_id: @data_import.id,
+      source_provider: @source.provider,
+      source_object_type: 'message',
+      source_object_id: entry.source_id,
+      chatwoot_record_type: record_type,
+      chatwoot_record_id: record_id,
+      metadata: metadata,
+      created_at: entry.mapping&.created_at || now,
+      updated_at: now
+    }
+  end
+
+  def record_bulk_skipped_message(conversation, entry)
+    already_recorded = skip_log_recorded?('message', entry.source_id, @source.skipped_message_error_code)
+    record_skipped_message_log(conversation, entry.source_id, entry.part)
+    increment_stat('messages', 'skipped') unless already_recorded
+  end
+
+  def reconcile_bulk_message_entry(conversation, entry, &)
+    with_query_timeout_retry(&)
+  rescue StandardError => e
+    fail_message(conversation, entry.source_id, entry.part, e)
+  end
+
+  def import_conversation_messages_individually(conversation, chatwoot_conversation, contact, batch_builder, parts_count)
+    source_entries, part_entries = batch_builder.unprepared_entries.partition { |entry| entry[:part]['part_type'] == 'source' }
+    source_entries.each { |entry| import_unprepared_message(chatwoot_conversation, contact, batch_builder, entry) }
+    record_truncated_conversation_parts(conversation, parts_count)
+
+    part_entries.each do |entry|
+      return false unless continue_import_with_heartbeat?
+
+      import_unprepared_message(chatwoot_conversation, contact, batch_builder, entry)
+    end
+    return false if import_stopped?
+
+    true
+  end
+
+  def import_unprepared_message(conversation, contact, batch_builder, source_entry)
+    with_query_timeout_retry do
+      @data_import.with_lock do
+        if inactive_import_run?
+          @import_stopped = true
+          next
+        end
+
+        entry = batch_builder.perform([source_entry]).entries.first
+        import_message(conversation, contact, entry)
+      end
+    end
+  rescue StandardError => e
+    fail_message(conversation, source_entry[:source_id], source_entry[:part], e)
+  end
+
+  def import_message(conversation, contact, entry, reindex: true)
+    message = with_query_timeout_retry do
+      Message.transaction(requires_new: true) do
+        case entry.classification
+        when :current_import
+          reconcile_current_run_message_mapping(conversation, entry.mapping, entry.part)
+        when :previous_import
+          skip_existing_message_mapping(conversation, entry.mapping, entry.part)
+        when :repairable_stale_mapping, :existing_message, :new_message
+          create_message(conversation, contact, entry)
+        else
+          raise ArgumentError, "Unsupported #{@source.display_name} message classification: #{entry.classification}"
+        end
+      end
+    end
+    reindex_message_for_search(message) if reindex && message.is_a?(Message)
+    message
+  rescue StandardError => e
+    fail_message(conversation, entry.source_id, entry.part, e)
+  end
+
+  def create_message(conversation, contact, entry)
+    validate_message_payload!(entry.part)
+    content = content_for(entry.part)
+    return record_skipped_message(conversation, entry) if content.blank?
+
+    attrs = message_attributes(conversation, contact, entry.part, entry.source_id, content)
+    message = entry.message
+    unless message
+      result = Message.insert_all!([attrs], returning: %w[id])
+      message = Message.find(result.rows.first.first)
+    end
+    record_message_mapping(entry, message)
+    increment_stat('messages', 'imported')
+    message
+  end
+
+  def reindex_message_for_search(message)
+    return unless message.should_index?
+
+    message.__send__(:reindex_for_search)
+  rescue StandardError => e
+    Rails.logger.warn("#{@source.display_name} import message reindex failed for message #{message.id}: #{e.class} - #{e.message}")
+  end
+
+  def record_skipped_message(conversation, entry)
+    if entry.mapping
+      already_recorded = skip_log_recorded?('message', entry.source_id, @source.skipped_message_error_code)
+      record_skipped_message_log(conversation, entry.source_id, entry.part)
+      increment_stat('messages', 'skipped') unless already_recorded
+      return entry.message
+    end
+
+    DataImportMapping.create!(
+      account: @account,
+      data_import: @data_import,
+      source_provider: @source.provider,
+      source_object_type: 'message',
+      source_object_id: entry.source_id,
+      chatwoot_record_type: 'Conversation',
+      chatwoot_record_id: conversation.id,
+      metadata: message_metadata(entry.part).merge(skipped: true, reason: @source.skipped_message_reason)
+    )
+    record_skipped_message_log(conversation, entry.source_id, entry.part)
+    increment_stat('messages', 'skipped')
+  end
+
+  def record_message_mapping(entry, message)
+    (entry.mapping || DataImportMapping.new(
+      account: @account,
+      source_provider: @source.provider,
+      source_object_type: 'message',
+      source_object_id: entry.source_id
+    )).tap do |mapping|
+      mapping.data_import = @data_import
+      mapping.chatwoot_record_type = 'Message'
+      mapping.chatwoot_record_id = message.id
+      mapping.metadata = message_metadata(entry.part)
+      mapping.save!
+    end
+  end
+
+  def message_attributes(conversation, contact, part, message_source_id, content)
+    message_type = message_type_for(part)
+    sender = message_sender_for(part, contact, message_type)
+    created_at = timestamp_for(part['created_at'])
+    {
+      account_id: @account.id,
+      inbox_id: conversation.inbox_id,
+      conversation_id: conversation.id,
+      message_type: Message.message_types[message_type],
+      content_type: Message.content_types['text'],
+      content: content,
+      processed_message_content: content,
+      private: message_type != 'activity' && part['part_type'] == 'note',
+      status: Message.statuses['sent'],
+      sender_type: sender.present? ? 'Contact' : nil,
+      sender_id: sender&.id,
+      source_id: "#{@source.provider}:#{message_source_id}",
+      external_source_ids: { @source.provider => message_source_id },
+      content_attributes: {},
+      additional_attributes: message_metadata(part),
+      created_at: created_at,
+      updated_at: part['updated_at'].present? ? timestamp_for(part['updated_at']) : created_at
+    }
+  end
+
+  def message_type_for(part)
+    return 'activity' if activity_part?(part)
+
+    author_type = part.dig('author', 'type').to_s
+    return 'incoming' if %w[user contact lead].include?(author_type)
+
+    'outgoing'
+  end
+
+  def content_for(part)
+    return @source.activity_content(part) if activity_part?(part)
+
+    message_content(part)
+  end
+
+  def activity_part?(part)
+    @source.activity_part?(part)
+  end
+
+  def message_content(part)
+    body = sanitized_text(part['body'])
+    subject = sanitized_text(part['subject'])
+    attachments = Array(part['attachments'])
+    content = [subject, body].reject(&:blank?).join("\n\n")
+    return content if attachments.blank?
+
+    [content.presence, "[#{@source.display_name} attachment skipped: #{attachments.size}]"].compact.join("\n\n")
+  end
+
+  def sanitized_text(value)
+    Rails::HTML5::FullSanitizer.new.sanitize(value.to_s).squish
+  end
+
+  def update_conversation_activity(conversation)
+    latest_message = conversation.messages.reorder(created_at: :desc).first
+    return if latest_message.blank?
+
+    conversation.update_columns(last_activity_at: latest_message.created_at, updated_at: Time.current)
+  end
+
+  def contact_inbox_for(contact, inbox)
+    ContactInbox.find_or_create_by!(contact: contact, inbox: inbox) do |contact_inbox|
+      contact_inbox.source_id = "#{@source.provider}:#{contact.id}"
+    end
+  end
+
+  def conversation_contacts(conversation)
+    contacts = Array(conversation.dig('contacts', 'contacts'))
+    contacts.presence || [conversation.dig('source', 'author') || {}]
+  end
+
+  def message_sender_for(part, primary_contact, message_type)
+    return unless message_type == 'incoming'
+
+    author = part['author'].to_h
+    source_id = source_id_for(author)
+    mapped_contact = find_mapping('contact', source_id)&.chatwoot_record if source_id.present?
+    mapped_contact || find_existing_contact(author) || primary_contact
+  end
+
+  def conversation_source_type(conversation, conversation_summary)
+    conversation.dig('source', 'type').presence ||
+      conversation.dig('first_contact_reply', 'type').presence ||
+      conversation_summary.dig('source', 'type').presence ||
+      conversation_summary.dig('first_contact_reply', 'type').presence
+  end
+
+  def normalized_identifier(contact_payload)
+    contact_payload['external_id'].presence
+  end
+
+  def normalized_email(contact_payload)
+    email = contact_payload['email'].to_s.strip.downcase
+    email.match?(Devise.email_regexp) ? email : nil
+  end
+
+  def normalized_phone(contact_payload)
+    phone = contact_payload['phone'].to_s.strip
+    phone = "+#{phone}" if phone.match?(PHONE_WITHOUT_PLUS_REGEX)
+    phone.match?(E164_REGEX) ? phone : nil
+  end
+
+  def contact_activity_at(contact_payload)
+    return timestamp_for(contact_payload['last_seen_at']) if contact_payload['last_seen_at'].present?
+    return timestamp_for(contact_payload['last_replied_at']) if contact_payload['last_replied_at'].present?
+
+    nil
+  end
+
+  def source_id_for(payload)
+    payload['id'].presence || payload['external_id'].presence || payload['email'].presence
+  end
+
+  def conversation_identifier(conversation)
+    "#{@source.provider}:#{source_id_for(conversation)}"
+  end
+
+  def find_or_create_import_item(object_type, source_id)
+    attributes = {
+      source_provider: @source.provider,
+      source_object_type: object_type,
+      source_object_id: source_id
+    }
+    @data_import.items.find_by(attributes) || @data_import.items.create!(attributes)
+  rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique => e
+    @data_import.items.find_by(attributes) || raise(e)
+  end
+
+  def prepare_import_item(object_type, source_id, metadata)
+    item = find_or_create_import_item(object_type, source_id)
+    already_handled = item.with_lock do
+      already_handled = item.imported? || item.skipped?
+      item.status = :processing
+      item.attempt_count += 1
+      item.metadata = item.metadata.to_h.merge(metadata.to_h)
+      item.save!
+      already_handled
+    end
+    [item, already_handled]
+  end
+
+  def with_import_item_lock(item, already_handled:)
+    ApplicationRecord.connection_pool.with_connection do |connection|
+      lock_id = -item.id
+      connection.execute("SELECT pg_advisory_lock(#{lock_id})")
+      begin
+        item.reload
+        yield item, already_handled || item.imported? || item.skipped?
+      ensure
+        connection.execute("SELECT pg_advisory_unlock(#{lock_id})")
+      end
+    end
+  end
+
+  def find_mapping(object_type, source_id)
+    DataImportMapping.find_by(
+      account: @account,
+      source_provider: @source.provider,
+      source_object_type: object_type,
+      source_object_id: source_id
+    )
+  end
+
+  def record_mapping(object_type, source_id, record, metadata: {})
+    DataImportMapping.find_or_initialize_by(
+      account: @account,
+      source_provider: @source.provider,
+      source_object_type: object_type,
+      source_object_id: source_id
+    ).tap do |mapping|
+      mapping.data_import = @data_import
+      mapping.chatwoot_record_type = record.class.name
+      mapping.chatwoot_record_id = record.id
+      mapping.metadata = metadata
+      mapping.save!
+    end
+  end
+
+  def reconcile_current_run_contact(item, mapped_contact)
+    item.update!(status: :imported, chatwoot_record_type: 'Contact', chatwoot_record_id: mapped_contact.id)
+    mark_stat_group_dirty('contacts')
+  end
+
+  def reconcile_item_stats(source_object_type)
+    items = @data_import.items.where(source_provider: @source.provider, source_object_type: source_object_type)
+    group = stat_group_for(source_object_type)
+    @stats[group]['imported'] = items.imported.count
+    @stats[group]['skipped'] = items.skipped.count
+  end
+
+  def reconcile_current_run_message_mapping(conversation, mapping, part)
+    record_skipped_message_log(conversation, mapping.source_object_id, part) if mapping.metadata['skipped']
+    mark_stat_group_dirty('messages')
+  end
+
+  def reconcile_message_stats
+    mappings = @data_import.mappings.where(source_provider: @source.provider, source_object_type: 'message')
+    skipped_mappings = mappings.where("metadata ->> 'skipped' = ?", 'true').count
+    message_logs = @data_import.import_errors.where(source_object_type: 'message')
+    @stats['messages']['imported'] = mappings.count - skipped_mappings
+    @stats['messages']['skipped'] = message_logs.where("details ->> 'kind' = ?", 'skipped').count
+  end
+
+  def skip_already_imported_item(item, mapping, already_handled:)
+    DataImportItem.transaction do
+      item.update!(
+        status: :skipped,
+        chatwoot_record_type: mapping.chatwoot_record_type,
+        chatwoot_record_id: mapping.chatwoot_record_id,
+        last_error_code: @source.already_imported_error_code,
+        last_error_message: 'Already imported in a previous import.'
+      )
+      record_already_imported_log(
+        data_import_item: item,
+        source_object_type: item.source_object_type,
+        source_object_id: item.source_object_id,
+        mapping: mapping
+      )
+    end
+    increment_stat(stat_group_for(item.source_object_type), 'skipped') unless already_handled
+  end
+
+  def skip_existing_message_mapping(conversation, mapping, part)
+    if mapping.metadata['skipped']
+      already_recorded = skip_log_recorded?('message', mapping.source_object_id, @source.skipped_message_error_code)
+      record_skipped_message_log(conversation, mapping.source_object_id, part)
+    else
+      already_recorded = skip_log_recorded?('message', mapping.source_object_id, @source.already_imported_error_code)
+      record_already_imported_log(source_object_type: 'message', source_object_id: mapping.source_object_id, mapping: mapping)
+    end
+    if already_recorded
+      message_logs = @data_import.import_errors.where(source_object_type: 'message')
+      @stats['messages']['skipped'] = message_logs.where("details ->> 'kind' = ?", 'skipped').count
+    else
+      increment_stat('messages', 'skipped')
+    end
+  end
+
+  def fail_item(item, error)
+    increment_stat('errors', 'count')
+    item&.update!(status: :failed, last_error_code: error.class.name, last_error_message: error.message)
+    record_skip_log(
+      data_import_item: item,
+      source_object_type: item&.source_object_type,
+      source_object_id: item&.source_object_id,
+      error_code: error.class.name,
+      message: error.message,
+      details: {
+        kind: 'failed',
+        source_provider: @source.provider,
+        error_class: error.class.name
+      }
+    )
+  end
+
+  def fail_message(conversation, message_source_id, part, error)
+    increment_stat('errors', 'count')
+    record_skip_log(
+      source_object_type: 'message',
+      source_object_id: message_source_id,
+      error_code: error.class.name,
+      message: error.message,
+      details: message_metadata(part).merge(
+        kind: 'failed',
+        source_provider: @source.provider,
+        error_class: error.class.name,
+        conversation_id: conversation.identifier
+      )
+    )
+  end
+
+  def record_skipped_message_log(conversation, message_source_id, part)
+    record_skip_log(
+      source_object_type: 'message',
+      source_object_id: message_source_id,
+      error_code: @source.skipped_message_error_code,
+      message: skipped_message_log_message(part),
+      details: skipped_message_details(conversation, part)
+    )
+  end
+
+  def record_already_imported_log(source_object_type:, source_object_id:, mapping:, data_import_item: nil)
+    record_skip_log(
+      data_import_item: data_import_item,
+      source_object_type: source_object_type,
+      source_object_id: source_object_id,
+      error_code: @source.already_imported_error_code,
+      message: 'Already imported in a previous import.',
+      details: {
+        kind: 'skipped',
+        reason: 'already_imported',
+        source_provider: @source.provider,
+        previous_data_import_id: mapping.data_import_id,
+        chatwoot_record_type: mapping.chatwoot_record_type,
+        chatwoot_record_id: mapping.chatwoot_record_id
+      }
+    )
+  end
+
+  def record_truncated_conversation_parts(conversation, imported_parts_count)
+    total_parts_count = total_conversation_parts_count(conversation)
+    return if total_parts_count <= imported_parts_count
+
+    source_id = source_id_for(conversation)
+    already_recorded = @data_import.import_errors.exists?(
+      source_object_type: 'conversation',
+      source_object_id: source_id,
+      error_code: @source.truncated_parts_error_code
+    )
+    record_import_error(
+      source_object_type: 'conversation',
+      source_object_id: source_id,
+      error_code: @source.truncated_parts_error_code,
+      message: "#{@source.display_name} returned #{imported_parts_count} of #{total_parts_count} conversation parts.",
+      details: {
+        kind: 'incomplete',
+        source_provider: @source.provider,
+        imported_parts_count: imported_parts_count,
+        total_parts_count: total_parts_count
+      }
+    )
+    increment_stat('errors', 'count') unless already_recorded
+  end
+
+  def total_conversation_parts_count(conversation)
+    conversation_parts_total_count = conversation.dig('conversation_parts', 'total_count')
+    return conversation_parts_total_count.to_i if conversation_parts_total_count.present?
+
+    [
+      conversation.dig('statistics', 'count_conversation_parts'),
+      conversation.dig('statistics', 'count_conversations_parts')
+    ].compact.map(&:to_i).max || 0
+  end
+
+  def source_message_importable?(source)
+    @source.source_message_importable?(source)
+  end
+
+  def skipped_message_log_message(part)
+    "Skipped #{@source.display_name} #{source_event_name(part)} event#{source_part_id_suffix(part)}: #{skipped_message_reason_details(part)}."
+  end
+
+  def skipped_message_details(conversation, part)
+    author = part['author'].to_h
+    message_metadata(part).merge(
+      {
+        kind: 'skipped',
+        reason: @source.skipped_message_reason,
+        reason_details: skipped_message_reason_details(part),
+        event_name: source_event_name(part),
+        event_type: part['part_type'],
+        author_type: author['type'],
+        author_name: author['name'],
+        conversation_id: conversation.identifier
+      }.compact
+    )
+  end
+
+  def skipped_message_reason_details(part)
+    return 'message body did not contain readable text after HTML sanitization' if part['body'].present?
+    return 'attachments are present but no importable message text was found' if Array(part['attachments']).present?
+
+    'no message body or attachments to import'
+  end
+
+  def source_event_name(part)
+    part['part_type'].to_s.tr('_', ' ').presence || 'message part'
+  end
+
+  def source_part_id_suffix(part)
+    part['id'].present? ? " #{part['id']}" : ''
+  end
+
+  def skip_log_recorded?(source_object_type, source_object_id, error_code)
+    @data_import.import_errors.skip_logs.exists?(
+      source_object_type: source_object_type,
+      source_object_id: source_object_id,
+      error_code: error_code
+    )
+  end
+
+  def record_run_error(error)
+    @data_import.import_errors.create!(
+      error_code: error.class.name,
+      message: error.message,
+      details: {
+        kind: 'run_error',
+        source_provider: @source.provider,
+        error_class: error.class.name
+      }
+    )
+  end
+
+  def record_skip_log(attributes)
+    record_import_error(attributes)
+  end
+
+  def record_import_error(attributes)
+    @data_import.import_errors.find_or_initialize_by(
+      data_import_item: attributes[:data_import_item],
+      source_object_type: attributes[:source_object_type],
+      source_object_id: attributes[:source_object_id],
+      error_code: attributes[:error_code]
+    ).tap do |import_error|
+      import_error.message = attributes[:message]
+      import_error.details = attributes[:details]
+      import_error.save!
+    end
+  end
+
+  def conversation_metadata(conversation, inbox, source_type)
+    {
+      source: {
+        provider: @source.provider,
+        conversation_id: source_id_for(conversation),
+        source_type: source_type,
+        **@source.conversation_source_metadata(conversation),
+        routing_method: 'source_bucket_api_inbox',
+        routed_inbox_id: inbox.id,
+        import_id: @data_import.id
+      }.compact
+    }
+  end
+
+  def contact_metadata(contact_payload)
+    {
+      source: {
+        provider: @source.provider,
+        **@source.contact_source_metadata(contact_payload)
+      }.compact
+    }
+  end
+
+  def message_metadata(part)
+    {
+      source: {
+        provider: @source.provider,
+        **@source.message_source_metadata(part)
+      }.compact
+    }
+  end
+
+  def timestamp_for(value)
+    return Time.current if value.blank?
+
+    @source.timestamp_for(value)
+  end
+
+  def update_cursor(key, cursor)
+    @data_import.with_lock do
+      current_cursor = @data_import.cursor.to_h.deep_stringify_keys
+      if inactive_import_run?
+        @import_stopped = true
+        next current_cursor.dig(key, 'starting_after')
+      end
+
+      if current_cursor != @persisted_cursor
+        @persisted_cursor = current_cursor.deep_dup
+        next current_cursor.dig(key, 'starting_after')
+      end
+
+      updated_cursor = current_cursor.merge(
+        key => { starting_after: cursor, completed: cursor.blank?, updated_at: Time.current.iso8601 }
+      ).deep_stringify_keys
+      @data_import.update!(cursor: updated_cursor)
+      @persisted_cursor = updated_cursor.deep_dup
+      cursor
+    end
+  end
+
+  def stage_completed?(key)
+    @data_import.cursor&.dig(key, 'completed') == true
+  end
+
+  def import_type?(type)
+    import_types.include?(type)
+  end
+
+  def import_types
+    @import_types ||= (@data_import.import_types.presence || DEFAULT_IMPORT_TYPES)
+  end
+
+  def increment_stat(group, key, amount = 1)
+    @stats[group] ||= {}
+    @stats[group][key] = @stats[group][key].to_i + amount
+  end
+
+  def mark_stat_group_dirty(group)
+    @dirty_stat_groups[group] = true
+  end
+
+  def reconcile_dirty_stats
+    return if @dirty_stat_groups.empty?
+
+    with_query_timeout_retry do
+      @dirty_stat_groups.each_key do |group|
+        case group
+        when 'contacts'
+          reconcile_item_stats('contact')
+        when 'messages'
+          reconcile_message_stats
+        else
+          raise ArgumentError, "Unsupported #{@source.display_name} import stat group: #{group}"
+        end
+      end
+      persist_stats
+    end
+    @dirty_stat_groups.clear
+  end
+
+  def with_query_timeout_retry
+    retries = 0
+    begin
+      yield
+    rescue ActiveRecord::QueryCanceled
+      raise if retries >= QUERY_TIMEOUT_RETRY_LIMIT
+
+      retries += 1
+      sleep(rand(QUERY_TIMEOUT_RETRY_DELAY_RANGE))
+      retry
+    end
+  end
+
+  def update_stat_total(group, total)
+    @stats[group] ||= {}
+    @stats[group]['total'] = total.to_i
+    persist_stats
+  end
+
+  def update_message_total(item, conversation)
+    parts = conversation['conversation_parts'].to_h
+    conversation_parts_total = if parts.key?('total_count')
+                                 parts['total_count'].to_i
+                               else
+                                 Array(parts['conversation_parts']).size
+                               end
+    contribution = conversation_parts_total
+    contribution += 1 if source_message_importable?(conversation['source'].to_h)
+    previous_contribution = item.metadata.to_h['message_total_contribution'].to_i
+
+    @stats['messages']['total'] = @stats['messages']['total'].to_i + contribution - previous_contribution
+    item.update!(metadata: item.metadata.to_h.merge('message_total_contribution' => contribution))
+    persist_stats
+  end
+
+  def stat_group_for(source_object_type)
+    "#{source_object_type}s"
+  end
+
+  def persist_stats
+    @data_import.with_lock do
+      current_stats = default_stats.deep_merge(@data_import.stats || {})
+      reconcile_concurrent_stats(current_stats) if current_stats != @persisted_stats || @data_import.cursor.to_h != @persisted_cursor
+
+      @data_import.update_columns(stats: @stats, updated_at: Time.current)
+      @persisted_stats = @stats.deep_dup
+    end
+  end
+
+  def reconcile_concurrent_stats(current_stats)
+    local_stats = @stats
+    @stats = current_stats.deep_merge(local_stats)
+    %w[contacts conversations messages].each do |group|
+      totals = [current_stats.dig(group, 'total'), local_stats.dig(group, 'total')].compact
+      @stats[group]['total'] = totals.map(&:to_i).max if totals.any?
+    end
+
+    reconcile_item_stats('contact')
+    reconcile_item_stats('conversation')
+    reconcile_message_stats
+    @stats['errors']['count'] = @data_import.import_errors.non_skip_logs.count + @data_import.import_errors.failed.count
+  end
+
+  def default_stats
+    {
+      'contacts' => { 'imported' => 0, 'skipped' => 0 },
+      'conversations' => { 'imported' => 0, 'skipped' => 0 },
+      'messages' => { 'imported' => 0, 'skipped' => 0 },
+      'errors' => { 'count' => 0 }
+    }
+  end
+
+  def total_processed_records
+    total_successful_records +
+      @stats.fetch('contacts', {}).fetch('skipped', 0).to_i +
+      @stats.fetch('conversations', {}).fetch('skipped', 0).to_i +
+      @stats.fetch('messages', {}).fetch('skipped', 0).to_i +
+      @stats.fetch('errors', {}).fetch('count', 0).to_i
+  end
+
+  def total_successful_records
+    @stats.fetch('contacts', {}).fetch('imported', 0).to_i +
+      @stats.fetch('conversations', {}).fetch('imported', 0).to_i +
+      @stats.fetch('messages', {}).fetch('imported', 0).to_i
+  end
+end
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Rails/SkipsModelValidations
diff --git a/app/services/data_imports/intercom/creation_service.rb b/app/services/data_imports/intercom/creation_service.rb
index 401bbbeb4..fec687108 100644
--- a/app/services/data_imports/intercom/creation_service.rb
+++ b/app/services/data_imports/intercom/creation_service.rb
@@ -1,67 +1,2 @@
-class DataImports::Intercom::CreationService
-  def initialize(account:, initiated_by:, source_params:)
-    @account = account
-    @initiated_by = initiated_by
-    @source_params = source_params.symbolize_keys
-    @access_token = @source_params[:access_token].to_s.strip
-  end
-
-  def perform
-    return if active_import?
-
-    totals = validate_source
-    @account.with_lock do
-      next if active_import?
-
-      @account.data_imports.new(attributes(totals)).tap do |data_import|
-        data_import.assign_active_intercom_import_run_id
-        data_import.save!
-      end
-    end
-  end
-
-  private
-
-  def validate_source
-    raise ArgumentError, 'Unsupported import source.' unless @source_params[:source_provider] == 'intercom'
-
-    DataImports::Intercom::CredentialsValidator.new(
-      access_token: @access_token,
-      import_types: import_types
-    ).perform
-  end
-
-  def attributes(totals)
-    {
-      name: @source_params[:name].presence || 'Intercom import',
-      data_type: 'intercom',
-      source_type: 'api',
-      source_provider: 'intercom',
-      import_types: import_types,
-      initiated_by: @initiated_by,
-      access_token: @access_token,
-      stats: initial_stats(totals)
-    }
-  end
-
-  def import_types
-    return DataImports::Intercom::Importer::DEFAULT_IMPORT_TYPES unless @source_params.key?(:import_types)
-
-    Array(@source_params[:import_types]).compact_blank
-  end
-
-  def initial_stats(totals)
-    {
-      'contacts' => { 'imported' => 0, 'skipped' => 0 },
-      'conversations' => { 'imported' => 0, 'skipped' => 0 },
-      'messages' => { 'imported' => 0, 'skipped' => 0 },
-      'errors' => { 'count' => 0 }
-    }.tap do |stats|
-      totals.each { |type, total| stats[type]['total'] = total unless total.nil? }
-    end
-  end
-
-  def active_import?
-    @account.data_imports.active_intercom.exists?
-  end
+class DataImports::Intercom::CreationService < DataImports::CreationService
 end
diff --git a/app/services/data_imports/intercom/importer.rb b/app/services/data_imports/intercom/importer.rb
index 4d40d358c..15cb97aa5 100644
--- a/app/services/data_imports/intercom/importer.rb
+++ b/app/services/data_imports/intercom/importer.rb
@@ -1,1319 +1,6 @@
-# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Rails/SkipsModelValidations
-class DataImports::Intercom::Importer
-  class InvalidMessagePayloadError < StandardError; end
-
-  PageResult = Struct.new(:next_cursor, keyword_init: true) do
-    def done?
-      next_cursor.blank?
-    end
-  end
-
-  DEFAULT_IMPORT_TYPES = %w[contacts conversations].freeze
-  CONTACTS_PER_PAGE = 50
-  CONVERSATIONS_PER_PAGE = 10
-  MESSAGES_PER_BATCH = 100
-  HEARTBEAT_INTERVAL = 1.minute
-  QUERY_TIMEOUT_RETRY_LIMIT = 1
-  QUERY_TIMEOUT_RETRY_DELAY_RANGE = (0.2..0.5)
-  PROVIDER = 'intercom'.freeze
-  ALREADY_IMPORTED_ERROR_CODE = 'DataImports::Intercom::AlreadyImported'.freeze
-  SKIPPED_MESSAGE_ERROR_CODE = 'DataImports::Intercom::SkippedMessage'.freeze
-  TRUNCATED_PARTS_ERROR_CODE = 'DataImports::Intercom::TruncatedConversationParts'.freeze
-  MESSAGE_MAPPING_UNIQUE_INDEX = :idx_data_import_mappings_on_account_and_source
-  E164_REGEX = /\A\+[1-9]\d{1,14}\z/
-  INTERCOM_NUMBER_REGEX = /\A[1-9]\d{1,14}\z/
-
-  MessageBatchResult = Struct.new(
-    :imported_entries,
-    :skipped_entries,
-    :current_entries,
-    :previous_entries,
-    :messages,
-    :failed_entries,
-    keyword_init: true
-  )
-
-  def initialize(data_import:, run_id: nil)
-    @data_import = data_import
-    @run_id = run_id
-    @account = data_import.account
-    @client = DataImports::Intercom::Client.new(access_token: data_import.access_token)
-    @placeholder_inboxes = DataImports::Intercom::PlaceholderInboxBuilder.new(account: @account)
-    @stats = default_stats.deep_merge(data_import.stats || {})
-    @dirty_stat_groups = {}
-  end
-
-  def perform
-    return unless start!
-
-    import_contacts if import_type?('contacts')
-    import_conversations if import_type?('conversations')
-    finish!
-  rescue StandardError => e
-    fail!(e)
-    raise
-  end
-
-  def start!
-    return if @data_import.reload.abandoned?
-
-    @data_import.update!(status: :processing, started_at: @data_import.started_at || Time.current)
-  end
-
-  def finish!
-    @data_import.with_lock do
-      next if @data_import.abandoned? || stale_import_run?
-
-      error_count = @data_import.import_errors.non_skip_logs.count + @data_import.import_errors.failed.count
-      @stats['errors']['count'] = error_count
-      status = error_count.positive? ? :completed_with_errors : :completed
-      @data_import.update!(
-        status: status,
-        completed_at: Time.current,
-        stats: @stats,
-        total_records: total_processed_records,
-        processed_records: total_successful_records
-      )
-    end
-  end
-
-  def fail!(error)
-    @data_import.with_lock do
-      next if @data_import.abandoned? || stale_import_run?
-
-      record_run_error(error)
-      @data_import.update!(status: :failed, last_error_at: Time.current)
-    end
-  end
-
-  def import_contacts_page(starting_after: cursor_for('contacts'))
-    response = @client.list_contacts(starting_after: starting_after, per_page: CONTACTS_PER_PAGE)
-    update_stat_total('contacts', response['total_count']) if response['total_count'].present?
-    Array(response['data'] || response['contacts']).each do |contact|
-      break if import_stopped?
-
-      import_contact(contact)
-    end
-    return PageResult.new(next_cursor: nil) if import_stopped?
-
-    reconcile_dirty_stats
-    next_cursor = response.dig('pages', 'next', 'starting_after')
-    update_cursor('contacts', next_cursor)
-    PageResult.new(next_cursor: next_cursor)
-  end
-
-  def import_conversations_page(starting_after: cursor_for('conversations'))
-    response = @client.list_conversations(starting_after: starting_after, per_page: CONVERSATIONS_PER_PAGE)
-    update_stat_total('conversations', response['total_count']) if response['total_count'].present?
-    Array(response['data'] || response['conversations']).each do |conversation_summary|
-      break if import_stopped?
-
-      import_conversation_from_summary(conversation_summary)
-    end
-    return PageResult.new(next_cursor: nil) if import_stopped?
-
-    reconcile_dirty_stats
-    next_cursor = response.dig('pages', 'next', 'starting_after')
-    update_cursor('conversations', next_cursor)
-    PageResult.new(next_cursor: next_cursor)
-  end
-
-  def import_contacts?
-    import_type?('contacts')
-  end
-
-  def import_conversations?
-    import_type?('conversations')
-  end
-
-  def contacts_completed?
-    stage_completed?('contacts')
-  end
-
-  def conversations_completed?
-    stage_completed?('conversations')
-  end
-
-  def cursor_for(key)
-    @data_import.cursor&.dig(key, 'starting_after')
-  end
-
-  private
-
-  def import_contacts
-    cursor = cursor_for('contacts')
-    loop do
-      result = import_contacts_page(starting_after: cursor)
-      break if result.done?
-
-      cursor = result.next_cursor
-    end
-  end
-
-  def import_conversations
-    cursor = cursor_for('conversations')
-    loop do
-      result = import_conversations_page(starting_after: cursor)
-      break if result.done?
-
-      cursor = result.next_cursor
-    end
-  end
-
-  def import_conversation_from_summary(conversation_summary)
-    source_id = source_id_for(conversation_summary)
-    already_handled = item_handled?('conversation', source_id)
-    item = import_item('conversation', source_id, conversation_summary)
-    mapping = find_mapping('conversation', source_id)
-
-    conversation = @client.retrieve_conversation(source_id)
-    return if import_stopped?
-
-    update_message_total(item, conversation)
-
-    contact = import_contact(primary_conversation_contact(conversation), required_for_conversation: true)
-    source_type = conversation_source_type(conversation, conversation_summary)
-    inbox = @placeholder_inboxes.inbox_for(source_type)
-    contact_inbox = contact_inbox_for(contact, inbox)
-
-    mapped_conversation = mapping&.chatwoot_record
-    if mapped_conversation && mapping.data_import_id != @data_import.id
-      skip_already_imported_item(item, mapping, already_handled: already_handled)
-      reconcile_item_stats('conversation') if already_handled
-      return unless import_conversation_messages(conversation, mapped_conversation, contact)
-
-      update_conversation_activity(mapped_conversation)
-      return
-    end
-
-    chatwoot_conversation = mapped_conversation || create_conversation(conversation, contact, contact_inbox, inbox, source_type)
-    if mapped_conversation
-      record_mapping('conversation', source_id, chatwoot_conversation, metadata: conversation_metadata(conversation, inbox, source_type))
-    end
-    item.update!(status: :imported, chatwoot_record_type: 'Conversation', chatwoot_record_id: chatwoot_conversation.id)
-    if already_handled
-      reconcile_item_stats('conversation')
-    else
-      increment_stat('conversations', 'imported')
-    end
-
-    return unless import_conversation_messages(conversation, chatwoot_conversation, contact)
-
-    update_conversation_activity(chatwoot_conversation)
-  rescue StandardError => e
-    raise if e.is_a?(DataImports::Intercom::Client::Error)
-
-    fail_item(item, e)
-  ensure
-    persist_stats unless @import_stopped
-  end
-
-  def import_stopped?
-    return true if @import_stopped
-
-    @data_import.reload
-    @import_stopped = @data_import.abandoned? || @data_import.completed? || @data_import.completed_with_errors? || stale_import_run?
-  end
-
-  def continue_import_with_heartbeat?
-    return false if import_stopped?
-    return true if @data_import.updated_at > HEARTBEAT_INTERVAL.ago
-
-    @data_import.touch if @data_import.updated_at <= HEARTBEAT_INTERVAL.ago
-    true
-  end
-
-  def stale_import_run?
-    active_run_id = @data_import.active_intercom_import_run_id
-    @run_id.present? && active_run_id.present? && active_run_id != @run_id
-  end
-
-  def import_contact(contact_payload, required_for_conversation: false)
-    item = nil
-    with_query_timeout_retry do
-      source_id = source_id_for(contact_payload)
-      if source_id.present? && (mapping = find_mapping('contact', source_id)) && (mapped_contact = mapping.chatwoot_record)
-        return reuse_mapped_contact(contact_payload, source_id, mapping, mapped_contact)
-      end
-
-      contact_payload = retrieve_contact_payload(contact_payload)
-      source_id = source_id_for(contact_payload)
-      already_handled = item_handled?('contact', source_id)
-      item = import_item('contact', source_id, contact_payload)
-      mapping = find_mapping('contact', source_id)
-
-      mapped_contact = mapping&.chatwoot_record
-      if mapped_contact && mapping.data_import_id != @data_import.id
-        skip_already_imported_item(item, mapping, already_handled: already_handled)
-        return mapped_contact
-      end
-
-      contact = Contact.transaction do
-        imported_contact = mapped_contact || find_existing_contact(contact_payload) || create_contact(contact_payload)
-        update_existing_contact(imported_contact, contact_payload)
-        record_mapping('contact', source_id, imported_contact, metadata: contact_metadata(contact_payload))
-        item.update!(status: :imported, chatwoot_record_type: 'Contact', chatwoot_record_id: imported_contact.id)
-        imported_contact
-      end
-      increment_stat('contacts', 'imported') unless already_handled
-      contact
-    end
-  rescue StandardError => e
-    raise if e.is_a?(DataImports::Intercom::Client::Error)
-
-    fail_item(item, e)
-    raise if required_for_conversation
-  ensure
-    persist_stats
-  end
-
-  def retrieve_contact_payload(contact_payload)
-    return contact_payload if contact_payload.blank?
-    return contact_payload if contact_payload['email'].present? || contact_payload['phone'].present? || contact_payload['name'].present?
-    return contact_payload if contact_payload['id'].blank?
-
-    @client.retrieve_contact(contact_payload['id'])
-  rescue DataImports::Intercom::Client::Error => e
-    raise unless e.status == 404
-
-    contact_payload
-  end
-
-  def create_contact(contact_payload)
-    attrs = contact_attributes(contact_payload).merge(created_at: timestamp_for(contact_payload['created_at']), updated_at: Time.current)
-    result = Contact.insert_all!([attrs], returning: %w[id])
-    Contact.find(result.rows.first.first)
-  rescue ActiveRecord::RecordNotUnique
-    find_existing_contact(contact_payload)
-  end
-
-  def reuse_mapped_contact(contact_payload, source_id, mapping, mapped_contact)
-    if mapping.data_import_id == @data_import.id
-      reconcile_current_run_contact(contact_payload, source_id, mapped_contact)
-      return mapped_contact
-    end
-
-    already_handled = item_handled?('contact', source_id)
-    item = import_item('contact', source_id, contact_payload)
-    skip_already_imported_item(item, mapping, already_handled: already_handled)
-    mapped_contact
-  end
-
-  def update_existing_contact(contact, contact_payload)
-    attrs = contact_attributes(contact_payload)
-    updates = {}
-    updates[:name] = attrs[:name] if contact.name.blank? && attrs[:name].present?
-    updates[:email] = attrs[:email] if contact_email_available?(contact, attrs[:email])
-    updates[:phone_number] = attrs[:phone_number] if contact_phone_number_available?(contact, attrs[:phone_number])
-    updates[:identifier] = attrs[:identifier] if contact.identifier.blank? && attrs[:identifier].present?
-    updates[:last_activity_at] = attrs[:last_activity_at] if contact.last_activity_at.blank? && attrs[:last_activity_at].present?
-    updates[:additional_attributes] = contact.additional_attributes.to_h.deep_merge(attrs[:additional_attributes])
-    updates[:custom_attributes] = contact.custom_attributes.to_h.deep_merge(attrs[:custom_attributes])
-    if contact.visitor? && attrs[:contact_type].present? && contact_resolved_after_update?(contact, updates)
-      updates[:contact_type] = attrs[:contact_type]
-    end
-    updates[:updated_at] = Time.current
-    contact.update_columns(updates) if updates.present?
-    contact.reload
-  end
-
-  def contact_email_available?(contact, email)
-    return false if contact.email.present? || email.blank?
-
-    @account.contacts.where.not(id: contact.id).where('LOWER(email) = ?', email.downcase).empty?
-  end
-
-  def contact_phone_number_available?(contact, phone_number)
-    return false if contact.phone_number.present? || phone_number.blank?
-
-    @account.contacts.where.not(id: contact.id).where(phone_number: phone_number).empty?
-  end
-
-  def contact_resolved_after_update?(contact, updates)
-    contact.email.present? || contact.phone_number.present? || updates[:email].present? || updates[:phone_number].present?
-  end
-
-  def find_existing_contact(contact_payload)
-    identifier = normalized_identifier(contact_payload)
-    email = normalized_email(contact_payload)
-    phone_number = normalized_phone(contact_payload)
-
-    if identifier.present?
-      contact = @account.contacts.find_by(identifier: identifier)
-      return contact if contact.present?
-    end
-
-    if email.present?
-      contact = @account.contacts.from_email(email)
-      return contact if contact.present?
-    end
-    return @account.contacts.find_by(phone_number: phone_number) if phone_number.present?
-
-    nil
-  end
-
-  def contact_attributes(contact_payload)
-    attrs = {
-      account_id: @account.id,
-      name: contact_payload['name'].presence || contact_payload['email'].presence || '',
-      email: normalized_email(contact_payload),
-      phone_number: normalized_phone(contact_payload),
-      identifier: normalized_identifier(contact_payload),
-      last_activity_at: contact_activity_at(contact_payload),
-      additional_attributes: {
-        source: {
-          provider: PROVIDER,
-          contact_id: contact_payload['id'],
-          external_id: contact_payload['external_id'],
-          raw_phone: contact_payload['phone']
-        }.compact
-      },
-      custom_attributes: {
-        intercom_contact_id: contact_payload['id'],
-        intercom_external_id: contact_payload['external_id']
-      }.compact
-    }
-    attrs[:contact_type] = Contact.contact_types[:lead] if attrs[:email].present? || attrs[:phone_number].present?
-    attrs
-  end
-
-  def create_conversation(conversation, contact, contact_inbox, inbox, source_type)
-    source_id = source_id_for(conversation)
-    metadata = conversation_metadata(conversation, inbox, source_type)
-    if (existing_conversation = @account.conversations.find_by(identifier: conversation_identifier(conversation)))
-      record_mapping('conversation', source_id, existing_conversation, metadata: metadata)
-      return existing_conversation
-    end
-
-    attrs = {
-      account_id: @account.id,
-      inbox_id: inbox.id,
-      status: Conversation.statuses['resolved'],
-      contact_id: contact.id,
-      contact_inbox_id: contact_inbox.id,
-      identifier: conversation_identifier(conversation),
-      additional_attributes: metadata,
-      custom_attributes: { intercom_conversation_id: source_id },
-      created_at: timestamp_for(conversation['created_at']),
-      updated_at: timestamp_for(conversation['updated_at']),
-      last_activity_at: timestamp_for(conversation['updated_at'])
-    }
-
-    Conversation.transaction do
-      result = Conversation.insert_all!([attrs], returning: %w[id])
-      chatwoot_conversation = Conversation.find(result.rows.first.first)
-      record_mapping('conversation', source_id, chatwoot_conversation, metadata: metadata)
-      chatwoot_conversation
-    end
-  rescue ActiveRecord::RecordNotUnique
-    @account.conversations.find_by!(identifier: conversation_identifier(conversation)).tap do |chatwoot_conversation|
-      record_mapping('conversation', source_id, chatwoot_conversation, metadata: metadata)
-    end
-  end
-
-  def import_conversation_messages(conversation, chatwoot_conversation, contact)
-    parts_payload = conversation['conversation_parts'].to_h
-    parts = Array(parts_payload['conversation_parts'])
-    batch_builder = DataImports::Intercom::MessageBatchBuilder.new(
-      data_import: @data_import,
-      conversation: chatwoot_conversation,
-      source_conversation: conversation
-    )
-    batch = begin
-      with_query_timeout_retry { batch_builder.perform }
-    rescue ActiveRecord::QueryCanceled
-      nil
-    end
-    return import_conversation_messages_individually(conversation, chatwoot_conversation, contact, batch_builder, parts.size) if batch.nil?
-
-    record_truncated_conversation_parts(conversation, parts.size)
-
-    batch.entries.each_slice(MESSAGES_PER_BATCH) do |entries|
-      return false unless continue_import_with_heartbeat?
-
-      import_message_batch(chatwoot_conversation, contact, batch_builder, entries)
-      return false if @import_stopped
-    end
-    return false if import_stopped?
-
-    true
-  end
-
-  def import_message_batch(conversation, contact, batch_builder, entries)
-    result = bulk_message_batch_result(conversation, contact, batch_builder, entries)
-    return if result.blank?
-
-    result.current_entries.each do |entry|
-      reconcile_bulk_message_entry(conversation, entry) do
-        reconcile_current_run_message_mapping(conversation, entry.mapping, entry.part)
-      end
-    end
-    result.previous_entries.each do |entry|
-      reconcile_bulk_message_entry(conversation, entry) do
-        skip_existing_message_mapping(conversation, entry.mapping, entry.part)
-      end
-    end
-    result.skipped_entries.each do |entry|
-      reconcile_bulk_message_entry(conversation, entry) { record_bulk_skipped_message(conversation, entry) }
-    end
-    Array(result.failed_entries).each { |entry, error| fail_message(conversation, entry.source_id, entry.part, error) }
-    increment_stat('messages', 'imported', result.imported_entries.size)
-    result.messages.each { |message| reindex_message_for_search(message) }
-  end
-
-  def bulk_message_batch_result(conversation, contact, batch_builder, entries)
-    with_query_timeout_retry do
-      bulk_write_message_entries(conversation, contact, batch_builder, entries)
-    end
-  rescue ActiveRecord::ActiveRecordError
-    fallback_message_entries(conversation, contact, batch_builder, entries) unless @import_stopped
-    nil
-  end
-
-  def fallback_message_entries(conversation, contact, batch_builder, entries)
-    entries.each do |entry|
-      break unless continue_import_with_heartbeat?
-
-      message = fallback_message_entry(conversation, contact, batch_builder, entry)
-      reindex_message_for_search(message) if message.is_a?(Message)
-    end
-  end
-
-  def fallback_message_entry(conversation, contact, batch_builder, entry)
-    with_query_timeout_retry do
-      @data_import.with_lock do
-        if inactive_import_run?
-          @import_stopped = true
-          next
-        end
-
-        refreshed_entry = batch_builder.refresh([entry]).entries.first
-        import_message(conversation, contact, refreshed_entry, reindex: false)
-      end
-    end
-  rescue ActiveRecord::ActiveRecordError => e
-    fail_message(conversation, entry.source_id, entry.part, e)
-  end
-
-  def bulk_write_message_entries(conversation, contact, batch_builder, entries)
-    @data_import.with_lock do
-      if inactive_import_run?
-        @import_stopped = true
-        next
-      end
-
-      refreshed_entries = batch_builder.refresh(entries).entries
-      persist_message_entries(conversation, contact, refreshed_entries)
-    end
-  end
-
-  def inactive_import_run?
-    @data_import.abandoned? || @data_import.failed? || @data_import.completed? ||
-      @data_import.completed_with_errors? || stale_import_run?
-  end
-
-  def persist_message_entries(conversation, contact, entries)
-    grouped_entries = entries.group_by(&:classification)
-    writable_entries = entries.select do |entry|
-      %i[repairable_stale_mapping existing_message new_message].include?(entry.classification)
-    end
-    content_by_source_id = {}
-    attributes_by_source_id = {}
-    failed_entries = []
-    writable_entries.select! do |entry|
-      validate_message_payload!(entry.part)
-      content = content_for(entry.part)
-      content_by_source_id[entry.source_id] = content
-      if content.present? && entry.message.blank?
-        attributes_by_source_id[entry.source_id] = message_attributes(conversation, contact, entry.part, entry.source_id, content)
-      end
-      true
-    rescue InvalidMessagePayloadError => e
-      failed_entries << [entry, e]
-      false
-    end
-    skipped_entries, imported_entries = writable_entries.partition { |entry| content_by_source_id[entry.source_id].blank? }
-    messages = insert_messages(imported_entries, attributes_by_source_id)
-    upsert_message_mappings(conversation, imported_entries, skipped_entries, messages)
-
-    MessageBatchResult.new(
-      imported_entries: imported_entries,
-      skipped_entries: skipped_entries,
-      current_entries: grouped_entries.fetch(:current_import, []),
-      previous_entries: grouped_entries.fetch(:previous_import, []),
-      messages: messages,
-      failed_entries: failed_entries
-    )
-  end
-
-  def insert_messages(entries, attributes_by_source_id)
-    new_entries = entries.reject(&:message)
-    if new_entries.present?
-      attributes = new_entries.map { |entry| attributes_by_source_id.fetch(entry.source_id) }
-      result = Message.insert_all!(attributes, returning: %w[id source_id])
-      inserted_messages = Message.where(id: result.pluck('id')).index_by(&:source_id)
-    end
-
-    entries.map do |entry|
-      entry.message || inserted_messages.fetch("intercom:#{entry.source_id}")
-    end
-  end
-
-  def validate_message_payload!(part)
-    raise InvalidMessagePayloadError, 'Intercom message payload must be an object' unless part.is_a?(Hash)
-
-    %w[author assigned_to event_details].each do |field|
-      value = part[field]
-      next if value.nil? || value.is_a?(Hash)
-
-      raise InvalidMessagePayloadError, "Intercom message #{field} must be an object"
-    end
-
-    participant = part.dig('event_details', 'participant')
-    unless participant.nil? || participant.is_a?(Hash)
-      raise InvalidMessagePayloadError, 'Intercom message event_details.participant must be an object'
-    end
-
-    %w[created_at updated_at].each do |field|
-      value = part[field]
-      valid_timestamp = value.nil? || value.is_a?(Integer) || value.is_a?(Float) ||
-                        (value.is_a?(String) && (value.blank? || value.match?(/\A-?\d+(?:\.\d+)?\z/)))
-      raise InvalidMessagePayloadError, "Intercom message #{field} must be a Unix timestamp" unless valid_timestamp
-
-      timestamp_for(value) if value.present?
-    rescue RangeError
-      raise InvalidMessagePayloadError, "Intercom message #{field} must be a Unix timestamp"
-    end
-
-    %w[body subject].each do |field|
-      value = part[field]
-      next unless value.is_a?(String) && !value.valid_encoding?
-
-      raise InvalidMessagePayloadError, "Intercom message #{field} must use valid encoding"
-    end
-  end
-
-  def upsert_message_mappings(conversation, imported_entries, skipped_entries, messages)
-    now = Time.current
-    mapping_attributes = imported_entries.zip(messages).map do |entry, message|
-      message_mapping_attributes(entry, 'Message', message.id, message_metadata(entry.part), now)
-    end
-    mapping_attributes.concat(skipped_entries.filter_map do |entry|
-      next if entry.mapping
-
-      metadata = message_metadata(entry.part).merge(skipped: true, reason: 'blank_or_unsupported_intercom_part')
-      message_mapping_attributes(entry, 'Conversation', conversation.id, metadata, now)
-    end)
-    return if mapping_attributes.empty?
-
-    DataImportMapping.upsert_all(
-      mapping_attributes,
-      unique_by: MESSAGE_MAPPING_UNIQUE_INDEX,
-      update_only: %i[data_import_id chatwoot_record_type chatwoot_record_id metadata updated_at],
-      record_timestamps: false
-    )
-  end
-
-  def message_mapping_attributes(entry, record_type, record_id, metadata, now)
-    {
-      account_id: @account.id,
-      data_import_id: @data_import.id,
-      source_provider: PROVIDER,
-      source_object_type: 'message',
-      source_object_id: entry.source_id,
-      chatwoot_record_type: record_type,
-      chatwoot_record_id: record_id,
-      metadata: metadata,
-      created_at: entry.mapping&.created_at || now,
-      updated_at: now
-    }
-  end
-
-  def record_bulk_skipped_message(conversation, entry)
-    already_recorded = skip_log_recorded?('message', entry.source_id, SKIPPED_MESSAGE_ERROR_CODE)
-    record_skipped_message_log(conversation, entry.source_id, entry.part)
-    increment_stat('messages', 'skipped') unless already_recorded
-  end
-
-  def reconcile_bulk_message_entry(conversation, entry, &)
-    with_query_timeout_retry(&)
-  rescue StandardError => e
-    fail_message(conversation, entry.source_id, entry.part, e)
-  end
-
-  def import_conversation_messages_individually(conversation, chatwoot_conversation, contact, batch_builder, parts_count)
-    source_entries, part_entries = batch_builder.unprepared_entries.partition { |entry| entry[:part]['part_type'] == 'source' }
-    source_entries.each { |entry| import_unprepared_message(chatwoot_conversation, contact, batch_builder, entry) }
-    record_truncated_conversation_parts(conversation, parts_count)
-
-    part_entries.each do |entry|
-      return false unless continue_import_with_heartbeat?
-
-      import_unprepared_message(chatwoot_conversation, contact, batch_builder, entry)
-    end
-    return false if import_stopped?
-
-    true
-  end
-
-  def import_unprepared_message(conversation, contact, batch_builder, source_entry)
-    with_query_timeout_retry do
-      @data_import.with_lock do
-        if inactive_import_run?
-          @import_stopped = true
-          next
-        end
-
-        entry = batch_builder.perform([source_entry]).entries.first
-        import_message(conversation, contact, entry)
-      end
-    end
-  rescue StandardError => e
-    fail_message(conversation, source_entry[:source_id], source_entry[:part], e)
-  end
-
-  def import_message(conversation, contact, entry, reindex: true)
-    message = with_query_timeout_retry do
-      Message.transaction(requires_new: true) do
-        case entry.classification
-        when :current_import
-          reconcile_current_run_message_mapping(conversation, entry.mapping, entry.part)
-        when :previous_import
-          skip_existing_message_mapping(conversation, entry.mapping, entry.part)
-        when :repairable_stale_mapping, :existing_message, :new_message
-          create_message(conversation, contact, entry)
-        else
-          raise ArgumentError, "Unsupported Intercom message classification: #{entry.classification}"
-        end
-      end
-    end
-    reindex_message_for_search(message) if reindex && message.is_a?(Message)
-    message
-  rescue StandardError => e
-    fail_message(conversation, entry.source_id, entry.part, e)
-  end
-
-  def create_message(conversation, contact, entry)
-    validate_message_payload!(entry.part)
-    content = content_for(entry.part)
-    return record_skipped_message(conversation, entry) if content.blank?
-
-    attrs = message_attributes(conversation, contact, entry.part, entry.source_id, content)
-    message = entry.message
-    unless message
-      result = Message.insert_all!([attrs], returning: %w[id])
-      message = Message.find(result.rows.first.first)
-    end
-    record_message_mapping(entry, message)
-    increment_stat('messages', 'imported')
-    message
-  end
-
-  def reindex_message_for_search(message)
-    return unless message.should_index?
-
-    message.__send__(:reindex_for_search)
-  rescue StandardError => e
-    Rails.logger.warn("Intercom import message reindex failed for message #{message.id}: #{e.class} - #{e.message}")
-  end
-
-  def record_skipped_message(conversation, entry)
-    if entry.mapping
-      already_recorded = skip_log_recorded?('message', entry.source_id, SKIPPED_MESSAGE_ERROR_CODE)
-      record_skipped_message_log(conversation, entry.source_id, entry.part)
-      increment_stat('messages', 'skipped') unless already_recorded
-      return entry.message
-    end
-
-    DataImportMapping.create!(
-      account: @account,
-      data_import: @data_import,
-      source_provider: PROVIDER,
-      source_object_type: 'message',
-      source_object_id: entry.source_id,
-      chatwoot_record_type: 'Conversation',
-      chatwoot_record_id: conversation.id,
-      metadata: message_metadata(entry.part).merge(skipped: true, reason: 'blank_or_unsupported_intercom_part')
-    )
-    record_skipped_message_log(conversation, entry.source_id, entry.part)
-    increment_stat('messages', 'skipped')
-  end
-
-  def record_message_mapping(entry, message)
-    (entry.mapping || DataImportMapping.new(
-      account: @account,
-      source_provider: PROVIDER,
-      source_object_type: 'message',
-      source_object_id: entry.source_id
-    )).tap do |mapping|
-      mapping.data_import = @data_import
-      mapping.chatwoot_record_type = 'Message'
-      mapping.chatwoot_record_id = message.id
-      mapping.metadata = message_metadata(entry.part)
-      mapping.save!
-    end
-  end
-
-  def message_attributes(conversation, contact, part, message_source_id, content)
-    message_type = message_type_for(part)
-    created_at = timestamp_for(part['created_at'])
-    {
-      account_id: @account.id,
-      inbox_id: conversation.inbox_id,
-      conversation_id: conversation.id,
-      message_type: Message.message_types[message_type],
-      content_type: Message.content_types['text'],
-      content: content,
-      processed_message_content: content,
-      private: message_type != 'activity' && part['part_type'] == 'note',
-      status: Message.statuses['sent'],
-      sender_type: message_type == 'incoming' ? 'Contact' : nil,
-      sender_id: message_type == 'incoming' ? contact.id : nil,
-      source_id: "intercom:#{message_source_id}",
-      external_source_ids: { intercom: message_source_id },
-      content_attributes: {},
-      additional_attributes: message_metadata(part),
-      created_at: created_at,
-      updated_at: part['updated_at'].present? ? timestamp_for(part['updated_at']) : created_at
-    }
-  end
-
-  def message_type_for(part)
-    return 'activity' if activity_part?(part)
-
-    author_type = part.dig('author', 'type').to_s
-    return 'incoming' if %w[user contact lead].include?(author_type)
-
-    'outgoing'
-  end
-
-  def content_for(part)
-    return DataImports::Intercom::ActivityContentBuilder.new(part).perform if activity_part?(part)
-
-    message_content(part)
-  end
-
-  def activity_part?(part)
-    DataImports::Intercom::MessageBatchBuilder.activity_part?(part)
-  end
-
-  def message_content(part)
-    body = sanitized_text(part['body'])
-    subject = sanitized_text(part['subject'])
-    attachments = Array(part['attachments'])
-    content = [subject, body].reject(&:blank?).join("\n\n")
-    return content if attachments.blank?
-
-    [content.presence, "[Intercom attachment skipped: #{attachments.size}]"].compact.join("\n\n")
-  end
-
-  def sanitized_text(value)
-    Rails::HTML5::FullSanitizer.new.sanitize(value.to_s).squish
-  end
-
-  def update_conversation_activity(conversation)
-    latest_message = conversation.messages.reorder(created_at: :desc).first
-    return if latest_message.blank?
-
-    conversation.update_columns(last_activity_at: latest_message.created_at, updated_at: Time.current)
-  end
-
-  def contact_inbox_for(contact, inbox)
-    ContactInbox.find_or_create_by!(contact: contact, inbox: inbox) do |contact_inbox|
-      contact_inbox.source_id = "intercom:#{contact.id}"
-    end
-  end
-
-  def primary_conversation_contact(conversation)
-    contacts = conversation.dig('contacts', 'contacts') || []
-    contacts.first || conversation.dig('source', 'author') || {}
-  end
-
-  def conversation_source_type(conversation, conversation_summary)
-    conversation.dig('source', 'type').presence ||
-      conversation.dig('first_contact_reply', 'type').presence ||
-      conversation_summary.dig('source', 'type').presence ||
-      conversation_summary.dig('first_contact_reply', 'type').presence
-  end
-
-  def normalized_identifier(contact_payload)
-    contact_payload['external_id'].presence
-  end
-
-  def normalized_email(contact_payload)
-    email = contact_payload['email'].to_s.strip.downcase
-    email.match?(Devise.email_regexp) ? email : nil
-  end
-
-  def normalized_phone(contact_payload)
-    phone = contact_payload['phone'].to_s.strip
-    phone = "+#{phone}" if phone.match?(INTERCOM_NUMBER_REGEX)
-    phone.match?(E164_REGEX) ? phone : nil
-  end
-
-  def contact_activity_at(contact_payload)
-    return timestamp_for(contact_payload['last_seen_at']) if contact_payload['last_seen_at'].present?
-    return timestamp_for(contact_payload['last_replied_at']) if contact_payload['last_replied_at'].present?
-
-    nil
-  end
-
-  def source_id_for(payload)
-    payload['id'].presence || payload['external_id'].presence || payload['email'].presence
-  end
-
-  def conversation_identifier(conversation)
-    "intercom:#{source_id_for(conversation)}"
-  end
-
-  def import_item(object_type, source_id, metadata)
-    @data_import.items.find_or_initialize_by(
-      source_provider: PROVIDER,
-      source_object_type: object_type,
-      source_object_id: source_id
-    ).tap do |item|
-      item.status = :processing
-      item.attempt_count += 1
-      item.metadata = item.metadata.to_h.merge(metadata.to_h)
-      item.save!
-    end
-  end
-
-  def item_handled?(object_type, source_id)
-    @data_import.items.where(status: [:imported, :skipped]).exists?(
-      source_provider: PROVIDER,
-      source_object_type: object_type,
-      source_object_id: source_id
-    )
-  end
-
-  def find_mapping(object_type, source_id)
-    DataImportMapping.find_by(
-      account: @account,
-      source_provider: PROVIDER,
-      source_object_type: object_type,
-      source_object_id: source_id
-    )
-  end
-
-  def record_mapping(object_type, source_id, record, metadata: {})
-    DataImportMapping.find_or_initialize_by(
-      account: @account,
-      source_provider: PROVIDER,
-      source_object_type: object_type,
-      source_object_id: source_id
-    ).tap do |mapping|
-      mapping.data_import = @data_import
-      mapping.chatwoot_record_type = record.class.name
-      mapping.chatwoot_record_id = record.id
-      mapping.metadata = metadata
-      mapping.save!
-    end
-  end
-
-  def reconcile_current_run_contact(contact_payload, source_id, mapped_contact)
-    item = @data_import.items.find_by(
-      source_provider: PROVIDER,
-      source_object_type: 'contact',
-      source_object_id: source_id
-    )
-    item = import_item('contact', source_id, contact_payload) unless item&.imported?
-    item.update!(status: :imported, chatwoot_record_type: 'Contact', chatwoot_record_id: mapped_contact.id)
-    mark_stat_group_dirty('contacts')
-  end
-
-  def reconcile_item_stats(source_object_type)
-    items = @data_import.items.where(source_provider: PROVIDER, source_object_type: source_object_type)
-    group = stat_group_for(source_object_type)
-    @stats[group]['imported'] = items.imported.count
-    @stats[group]['skipped'] = items.skipped.count
-  end
-
-  def reconcile_current_run_message_mapping(conversation, mapping, part)
-    record_skipped_message_log(conversation, mapping.source_object_id, part) if mapping.metadata['skipped']
-    mark_stat_group_dirty('messages')
-  end
-
-  def reconcile_message_stats
-    mappings = @data_import.mappings.where(source_provider: PROVIDER, source_object_type: 'message')
-    skipped_mappings = mappings.where("metadata ->> 'skipped' = ?", 'true').count
-    message_logs = @data_import.import_errors.where(source_object_type: 'message')
-    @stats['messages']['imported'] = mappings.count - skipped_mappings
-    @stats['messages']['skipped'] = message_logs.where("details ->> 'kind' = ?", 'skipped').count
-  end
-
-  def skip_already_imported_item(item, mapping, already_handled:)
-    DataImportItem.transaction do
-      item.update!(
-        status: :skipped,
-        chatwoot_record_type: mapping.chatwoot_record_type,
-        chatwoot_record_id: mapping.chatwoot_record_id,
-        last_error_code: ALREADY_IMPORTED_ERROR_CODE,
-        last_error_message: 'Already imported in a previous import.'
-      )
-      record_already_imported_log(
-        data_import_item: item,
-        source_object_type: item.source_object_type,
-        source_object_id: item.source_object_id,
-        mapping: mapping
-      )
-    end
-    increment_stat(stat_group_for(item.source_object_type), 'skipped') unless already_handled
-  end
-
-  def skip_existing_message_mapping(conversation, mapping, part)
-    if mapping.metadata['skipped']
-      already_recorded = skip_log_recorded?('message', mapping.source_object_id, SKIPPED_MESSAGE_ERROR_CODE)
-      record_skipped_message_log(conversation, mapping.source_object_id, part)
-    else
-      already_recorded = skip_log_recorded?('message', mapping.source_object_id, ALREADY_IMPORTED_ERROR_CODE)
-      record_already_imported_log(source_object_type: 'message', source_object_id: mapping.source_object_id, mapping: mapping)
-    end
-    if already_recorded
-      message_logs = @data_import.import_errors.where(source_object_type: 'message')
-      @stats['messages']['skipped'] = message_logs.where("details ->> 'kind' = ?", 'skipped').count
-    else
-      increment_stat('messages', 'skipped')
-    end
-  end
-
-  def fail_item(item, error)
-    increment_stat('errors', 'count')
-    item&.update!(status: :failed, last_error_code: error.class.name, last_error_message: error.message)
-    record_skip_log(
-      data_import_item: item,
-      source_object_type: item&.source_object_type,
-      source_object_id: item&.source_object_id,
-      error_code: error.class.name,
-      message: error.message,
-      details: {
-        kind: 'failed',
-        source_provider: PROVIDER,
-        error_class: error.class.name
-      }
-    )
-  end
-
-  def fail_message(conversation, message_source_id, part, error)
-    increment_stat('errors', 'count')
-    record_skip_log(
-      source_object_type: 'message',
-      source_object_id: message_source_id,
-      error_code: error.class.name,
-      message: error.message,
-      details: message_metadata(part).merge(
-        kind: 'failed',
-        source_provider: PROVIDER,
-        error_class: error.class.name,
-        conversation_id: conversation.identifier
-      )
-    )
-  end
-
-  def record_skipped_message_log(conversation, message_source_id, part)
-    record_skip_log(
-      source_object_type: 'message',
-      source_object_id: message_source_id,
-      error_code: SKIPPED_MESSAGE_ERROR_CODE,
-      message: skipped_message_log_message(part),
-      details: skipped_message_details(conversation, part)
-    )
-  end
-
-  def record_already_imported_log(source_object_type:, source_object_id:, mapping:, data_import_item: nil)
-    record_skip_log(
-      data_import_item: data_import_item,
-      source_object_type: source_object_type,
-      source_object_id: source_object_id,
-      error_code: ALREADY_IMPORTED_ERROR_CODE,
-      message: 'Already imported in a previous import.',
-      details: {
-        kind: 'skipped',
-        reason: 'already_imported',
-        source_provider: PROVIDER,
-        previous_data_import_id: mapping.data_import_id,
-        chatwoot_record_type: mapping.chatwoot_record_type,
-        chatwoot_record_id: mapping.chatwoot_record_id
-      }
-    )
-  end
-
-  def record_truncated_conversation_parts(conversation, imported_parts_count)
-    total_parts_count = total_conversation_parts_count(conversation)
-    return if total_parts_count <= imported_parts_count
-
-    source_id = source_id_for(conversation)
-    already_recorded = @data_import.import_errors.exists?(
-      source_object_type: 'conversation',
-      source_object_id: source_id,
-      error_code: TRUNCATED_PARTS_ERROR_CODE
-    )
-    record_import_error(
-      source_object_type: 'conversation',
-      source_object_id: source_id,
-      error_code: TRUNCATED_PARTS_ERROR_CODE,
-      message: "Intercom returned #{imported_parts_count} of #{total_parts_count} conversation parts.",
-      details: {
-        kind: 'incomplete',
-        source_provider: PROVIDER,
-        imported_parts_count: imported_parts_count,
-        total_parts_count: total_parts_count
-      }
-    )
-    increment_stat('errors', 'count') unless already_recorded
-  end
-
-  def total_conversation_parts_count(conversation)
-    conversation_parts_total_count = conversation.dig('conversation_parts', 'total_count')
-    return conversation_parts_total_count.to_i if conversation_parts_total_count.present?
-
-    [
-      conversation.dig('statistics', 'count_conversation_parts'),
-      conversation.dig('statistics', 'count_conversations_parts')
-    ].compact.map(&:to_i).max || 0
-  end
-
-  def source_message_importable?(source)
-    DataImports::Intercom::MessageBatchBuilder.source_message_importable?(source)
-  end
-
-  def skipped_message_log_message(part)
-    "Skipped Intercom #{intercom_event_name(part)} event#{intercom_part_id_suffix(part)}: #{skipped_message_reason_details(part)}."
-  end
-
-  def skipped_message_details(conversation, part)
-    author = part['author'].to_h
-    message_metadata(part).merge(
-      {
-        kind: 'skipped',
-        reason: 'blank_or_unsupported_intercom_part',
-        reason_details: skipped_message_reason_details(part),
-        event_name: intercom_event_name(part),
-        event_type: part['part_type'],
-        author_type: author['type'],
-        author_name: author['name'],
-        conversation_id: conversation.identifier
-      }.compact
-    )
-  end
-
-  def skipped_message_reason_details(part)
-    return 'message body did not contain readable text after HTML sanitization' if part['body'].present?
-    return 'attachments are present but no importable message text was found' if Array(part['attachments']).present?
-
-    'no message body or attachments to import'
-  end
-
-  def intercom_event_name(part)
-    part['part_type'].to_s.tr('_', ' ').presence || 'message part'
-  end
-
-  def intercom_part_id_suffix(part)
-    part['id'].present? ? " #{part['id']}" : ''
-  end
-
-  def skip_log_recorded?(source_object_type, source_object_id, error_code)
-    @data_import.import_errors.skip_logs.exists?(
-      source_object_type: source_object_type,
-      source_object_id: source_object_id,
-      error_code: error_code
-    )
-  end
-
-  def record_run_error(error)
-    @data_import.import_errors.create!(
-      error_code: error.class.name,
-      message: error.message,
-      details: {
-        kind: 'run_error',
-        source_provider: PROVIDER,
-        error_class: error.class.name
-      }
-    )
-  end
-
-  def record_skip_log(attributes)
-    record_import_error(attributes)
-  end
-
-  def record_import_error(attributes)
-    @data_import.import_errors.find_or_initialize_by(
-      data_import_item: attributes[:data_import_item],
-      source_object_type: attributes[:source_object_type],
-      source_object_id: attributes[:source_object_id],
-      error_code: attributes[:error_code]
-    ).tap do |import_error|
-      import_error.message = attributes[:message]
-      import_error.details = attributes[:details]
-      import_error.save!
-    end
-  end
-
-  def conversation_metadata(conversation, inbox, source_type)
-    {
-      source: {
-        provider: PROVIDER,
-        conversation_id: source_id_for(conversation),
-        source_type: source_type,
-        delivered_as: conversation.dig('source', 'delivered_as'),
-        source_url: conversation.dig('source', 'url'),
-        admin_assignee_id: conversation['admin_assignee_id'],
-        team_assignee_id: conversation['team_assignee_id'],
-        state: conversation['state'],
-        open: conversation['open'],
-        routing_method: 'source_bucket_api_inbox',
-        routed_inbox_id: inbox.id,
-        import_id: @data_import.id
-      }.compact
-    }
-  end
-
-  def contact_metadata(contact_payload)
-    {
-      source: {
-        provider: PROVIDER,
-        contact_id: contact_payload['id'],
-        external_id: contact_payload['external_id']
-      }.compact
-    }
-  end
-
-  def message_metadata(part)
-    {
-      source: {
-        provider: PROVIDER,
-        part_id: part['id'],
-        part_type: part['part_type'],
-        author: part['author'],
-        assigned_to: part['assigned_to'],
-        state: part['state'],
-        tags: part['tags'],
-        event_details: part['event_details'],
-        app_package_code: part['app_package_code'],
-        metadata: part['metadata'],
-        attachments: part['attachments'],
-        redacted: part['redacted']
-      }.compact
-    }
-  end
-
-  def timestamp_for(value)
-    return Time.current if value.blank?
-
-    Time.zone.at(value.to_i)
-  end
-
-  def update_cursor(key, cursor)
-    @data_import.cursor = @data_import.cursor.to_h.merge(
-      key => { starting_after: cursor, completed: cursor.blank?, updated_at: Time.current.iso8601 }
-    )
-    @data_import.save!
-  end
-
-  def stage_completed?(key)
-    @data_import.cursor&.dig(key, 'completed') == true
-  end
-
-  def import_type?(type)
-    import_types.include?(type)
-  end
-
-  def import_types
-    @import_types ||= (@data_import.import_types.presence || DEFAULT_IMPORT_TYPES)
-  end
-
-  def increment_stat(group, key, amount = 1)
-    @stats[group] ||= {}
-    @stats[group][key] = @stats[group][key].to_i + amount
-  end
-
-  def mark_stat_group_dirty(group)
-    @dirty_stat_groups[group] = true
-  end
-
-  def reconcile_dirty_stats
-    return if @dirty_stat_groups.empty?
-
-    with_query_timeout_retry do
-      @dirty_stat_groups.each_key do |group|
-        case group
-        when 'contacts'
-          reconcile_item_stats('contact')
-        when 'messages'
-          reconcile_message_stats
-        else
-          raise ArgumentError, "Unsupported Intercom import stat group: #{group}"
-        end
-      end
-      persist_stats
-    end
-    @dirty_stat_groups.clear
-  end
-
-  def with_query_timeout_retry
-    retries = 0
-    begin
-      yield
-    rescue ActiveRecord::QueryCanceled
-      raise if retries >= QUERY_TIMEOUT_RETRY_LIMIT
-
-      retries += 1
-      sleep(rand(QUERY_TIMEOUT_RETRY_DELAY_RANGE))
-      retry
-    end
-  end
-
-  def update_stat_total(group, total)
-    @stats[group] ||= {}
-    @stats[group]['total'] = total.to_i
-    persist_stats
-  end
-
-  def update_message_total(item, conversation)
-    parts = conversation['conversation_parts'].to_h
-    conversation_parts_total = if parts.key?('total_count')
-                                 parts['total_count'].to_i
-                               else
-                                 Array(parts['conversation_parts']).size
-                               end
-    contribution = conversation_parts_total
-    contribution += 1 if source_message_importable?(conversation['source'].to_h)
-    previous_contribution = item.metadata.to_h['message_total_contribution'].to_i
-
-    @stats['messages']['total'] = @stats['messages']['total'].to_i + contribution - previous_contribution
-    item.update!(metadata: item.metadata.to_h.merge('message_total_contribution' => contribution))
-    persist_stats
-  end
-
-  def stat_group_for(source_object_type)
-    "#{source_object_type}s"
-  end
-
-  def persist_stats
-    @data_import.update_columns(stats: @stats, updated_at: Time.current)
-  end
-
-  def default_stats
-    {
-      'contacts' => { 'imported' => 0, 'skipped' => 0 },
-      'conversations' => { 'imported' => 0, 'skipped' => 0 },
-      'messages' => { 'imported' => 0, 'skipped' => 0 },
-      'errors' => { 'count' => 0 }
-    }
-  end
-
-  def total_processed_records
-    total_successful_records +
-      @stats.fetch('contacts', {}).fetch('skipped', 0).to_i +
-      @stats.fetch('conversations', {}).fetch('skipped', 0).to_i +
-      @stats.fetch('messages', {}).fetch('skipped', 0).to_i +
-      @stats.fetch('errors', {}).fetch('count', 0).to_i
-  end
-
-  def total_successful_records
-    @stats.fetch('contacts', {}).fetch('imported', 0).to_i +
-      @stats.fetch('conversations', {}).fetch('imported', 0).to_i +
-      @stats.fetch('messages', {}).fetch('imported', 0).to_i
-  end
+class DataImports::Intercom::Importer < DataImports::Importer
+  InvalidMessagePayloadError = DataImports::Importer::InvalidMessagePayloadError
+  ALREADY_IMPORTED_ERROR_CODE = DataImports::Intercom::Source::ALREADY_IMPORTED_ERROR_CODE
+  SKIPPED_MESSAGE_ERROR_CODE = DataImports::Intercom::Source::SKIPPED_MESSAGE_ERROR_CODE
+  TRUNCATED_PARTS_ERROR_CODE = DataImports::Intercom::Source::TRUNCATED_PARTS_ERROR_CODE
 end
-# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Rails/SkipsModelValidations
diff --git a/app/services/data_imports/intercom/message_batch_builder.rb b/app/services/data_imports/intercom/message_batch_builder.rb
index b4cb728cc..300312ad9 100644
--- a/app/services/data_imports/intercom/message_batch_builder.rb
+++ b/app/services/data_imports/intercom/message_batch_builder.rb
@@ -1,144 +1,5 @@
-class DataImports::Intercom::MessageBatchBuilder
-  PROVIDER = 'intercom'.freeze
-  REGULAR_PART_TYPES = %w[comment note source].freeze
-
-  Entry = Struct.new(:source_id, :part, :position, :mapping, :message, :classification, keyword_init: true) do
-    def source?
-      part['part_type'] == 'source'
-    end
-  end
-
-  Batch = Struct.new(:items, keyword_init: true) do
-    def entries
-      items
-    end
-
-    def source_entries
-      items.select(&:source?)
-    end
-
-    def part_entries
-      items.reject(&:source?)
-    end
-  end
-
-  def self.activity_part?(part)
-    part_type = part['part_type'].to_s
-    part_type.present? && REGULAR_PART_TYPES.exclude?(part_type)
-  end
-
-  def self.source_message_importable?(source)
-    source['body'].present? || source['subject'].present? || source['attachments'].present?
-  end
-
+class DataImports::Intercom::MessageBatchBuilder < DataImports::MessageBatchBuilder
   def initialize(data_import:, conversation:, source_conversation:)
-    @data_import = data_import
-    @account = data_import.account
-    @conversation = conversation
-    @source_conversation = source_conversation
-  end
-
-  def perform(source_entries = unprepared_entries)
-    classify(source_entries)
-  end
-
-  def refresh(entries)
-    classify(entries.map do |entry|
-      { source_id: entry.source_id, part: entry.part, position: entry.position }
-    end)
-  end
-
-  def unprepared_entries
-    ordered_source_entries.map.with_index { |entry, position| entry.merge(position: position) }
-  end
-
-  private
-
-  def classify(source_entries)
-    return Batch.new(items: []) if source_entries.empty?
-
-    mappings = message_mappings(source_entries)
-    messages = messages_for(source_entries, mappings)
-
-    Batch.new(items: source_entries.map.with_index do |source_entry, position|
-      build_entry(source_entry, source_entry.fetch(:position, position), mappings, messages)
-    end)
-  end
-
-  def ordered_source_entries
-    entries = []
-    source = @source_conversation['source'].to_h
-    if self.class.source_message_importable?(source)
-      entries << {
-        source_id: "conversation:#{source_conversation_id}:source:#{source['id'].presence || 'initial'}",
-        part: source.merge('part_type' => 'source', 'created_at' => @source_conversation['created_at'])
-      }
-    end
-
-    conversation_parts.each do |part|
-      entries << { source_id: "conversation:#{source_conversation_id}:part:#{part['id']}", part: part }
-    end
-    entries
-  end
-
-  def conversation_parts
-    Array(@source_conversation.dig('conversation_parts', 'conversation_parts'))
-  end
-
-  def source_conversation_id
-    @source_conversation['id'].presence || @source_conversation['external_id'].presence || @source_conversation['email'].presence
-  end
-
-  def message_mappings(source_entries)
-    DataImportMapping.where(
-      account: @account,
-      source_provider: PROVIDER,
-      source_object_type: 'message',
-      source_object_id: source_entries.pluck(:source_id)
-    ).index_by(&:source_object_id)
-  end
-
-  def messages_for(source_entries, mappings)
-    mapped_message_ids = mappings.values.filter_map do |mapping|
-      mapping.chatwoot_record_id if mapping.chatwoot_record_type == 'Message'
-    end
-    chatwoot_source_ids = source_entries.map { |entry| "intercom:#{entry[:source_id]}" }
-    messages = Message.where(id: mapped_message_ids).or(
-      Message.where(conversation_id: @conversation.id, source_id: chatwoot_source_ids)
-    ).to_a
-
-    {
-      by_id: messages.index_by(&:id),
-      by_source_id: messages.index_by(&:source_id)
-    }
-  end
-
-  def build_entry(source_entry, position, mappings, messages)
-    source_id = source_entry[:source_id]
-    mapping = mappings[source_id]
-    mapped_message = messages[:by_id][mapping.chatwoot_record_id] if mapping&.chatwoot_record_type == 'Message'
-    existing_message = messages[:by_source_id]["intercom:#{source_id}"]
-
-    Entry.new(
-      source_id: source_id,
-      part: source_entry[:part],
-      position: position,
-      mapping: mapping,
-      message: mapped_message || existing_message,
-      classification: classification_for(mapping, mapped_message, existing_message, source_entry[:part])
-    )
-  end
-
-  def classification_for(mapping, mapped_message, existing_message, part)
-    return existing_message.present? ? :existing_message : :new_message if mapping.blank?
-    return :repairable_stale_mapping unless mapping_handled?(mapping, mapped_message, part)
-
-    mapping.data_import_id == @data_import.id ? :current_import : :previous_import
-  end
-
-  def mapping_handled?(mapping, mapped_message, part)
-    return false if mapping.metadata['skipped'] && self.class.activity_part?(part)
-
-    mapping.metadata['skipped'] || mapped_message.present?
+    super(data_import: data_import, conversation: conversation, source_conversation: source_conversation, provider: 'intercom')
   end
 end
diff --git a/app/services/data_imports/intercom/placeholder_inbox_builder.rb b/app/services/data_imports/intercom/placeholder_inbox_builder.rb
index c46a1f439..767a84d50 100644
--- a/app/services/data_imports/intercom/placeholder_inbox_builder.rb
+++ b/app/services/data_imports/intercom/placeholder_inbox_builder.rb
@@ -1,41 +1,5 @@
-class DataImports::Intercom::PlaceholderInboxBuilder
-  AGENT_REPLY_TIME_WINDOW_HOURS = 1
-
+class DataImports::Intercom::PlaceholderInboxBuilder < DataImports::PlaceholderInboxBuilder
   def initialize(account:)
-    @account = account
-  end
-
-  def inbox_for(source_type)
-    bucket = DataImports::Intercom::SourceBucket.for(source_type)
-    placeholder_inboxes[bucket[:key]] ||= create_placeholder_inbox(bucket)
-  end
-
-  private
-
-  def placeholder_inboxes
-    @placeholder_inboxes ||= @account.inboxes.includes(:channel).where(channel_type: 'Channel::Api').each_with_object({}) do |inbox, inboxes|
-      attrs = inbox.channel.additional_attributes || {}
-      next unless attrs['source_provider'] == 'intercom' && attrs['import_placeholder'] == true
-
-      inboxes[attrs['source_bucket']] = inbox
-    end
-  end
-
-  def create_placeholder_inbox(bucket)
-    channel = @account.api_channels.create!(
-      additional_attributes: {
-        source_provider: 'intercom',
-        source_bucket: bucket[:key],
-        import_placeholder: true,
-        agent_reply_time_window: AGENT_REPLY_TIME_WINDOW_HOURS
-      }
-    )
-
-    @account.inboxes.create!(
-      name: "Intercom Import - #{bucket[:name]}",
-      channel: channel,
-      enable_auto_assignment: false,
-      allow_messages_after_resolved: false
-    )
+    super(account: account, provider: 'intercom', source_bucket: DataImports::Intercom::SourceBucket)
   end
 end
diff --git a/app/services/data_imports/intercom/restart_service.rb b/app/services/data_imports/intercom/restart_service.rb
index 6fd55c633..649288821 100644
--- a/app/services/data_imports/intercom/restart_service.rb
+++ b/app/services/data_imports/intercom/restart_service.rb
@@ -1,55 +1,2 @@
-class DataImports::Intercom::RestartService
-  attr_reader :data_import
-
-  def initialize(account:, data_import:)
-    @account = account
-    @data_import = data_import
-  end
-
-  def perform
-    @account.with_lock do
-      @data_import.reload
-      next :render_show unless @data_import.restartable?
-
-      if (active_import = find_active_import)
-        @data_import = active_import
-        next :render_show
-      end
-
-      next :access_token_missing if @data_import.access_token.blank?
-
-      @data_import.assign_active_intercom_import_run_id
-      retained_skip_logs = @data_import.import_errors.where("details ->> 'kind' = ?", 'skipped')
-      @data_import.import_errors.where.not(id: retained_skip_logs.select(:id)).delete_all
-      @data_import.update!(restart_attributes(retained_skip_logs))
-      :enqueue
-    end
-  end
-
-  private
-
-  def find_active_import
-    @account.data_imports.active_intercom.first
-  end
-
-  def restart_attributes(retained_skip_logs)
-    {
-      status: :pending,
-      abandoned_at: nil,
-      completed_at: nil,
-      last_error_at: nil,
-      started_at: nil,
-      stats: restart_stats(retained_skip_logs)
-    }
-  end
-
-  def restart_stats(retained_skip_logs)
-    @data_import.stats.to_h.deep_dup.tap do |stats|
-      %w[contact conversation message].each do |object_type|
-        stats["#{object_type}s"] ||= {}
-        stats["#{object_type}s"]['skipped'] = retained_skip_logs.where(source_object_type: object_type).count
-      end
-      stats['errors'] = { 'count' => 0 }
-    end
-  end
+class DataImports::Intercom::RestartService < DataImports::RestartService
 end
diff --git a/app/services/data_imports/intercom/retry_service.rb b/app/services/data_imports/intercom/retry_service.rb
index 57289d917..631038b27 100644
--- a/app/services/data_imports/intercom/retry_service.rb
+++ b/app/services/data_imports/intercom/retry_service.rb
@@ -1,28 +1,2 @@
-class DataImports::Intercom::RetryService
-  attr_reader :data_import
-
-  def initialize(account:, data_import:)
-    @account = account
-    @data_import = data_import
-  end
-
-  def perform
-    @account.with_lock do
-      @data_import.with_lock do
-        next :not_stalled unless @data_import.stalled?
-        next :active_import_exists if another_active_import?
-        next :access_token_missing if @data_import.access_token.blank?
-
-        @data_import.assign_active_intercom_import_run_id
-        @data_import.update!(status: :pending)
-        :enqueue
-      end
-    end
-  end
-
-  private
-
-  def another_active_import?
-    @account.data_imports.active_intercom.where.not(id: @data_import.id).exists?
-  end
+class DataImports::Intercom::RetryService < DataImports::RetryService
 end
diff --git a/app/services/data_imports/intercom/source.rb b/app/services/data_imports/intercom/source.rb
new file mode 100644
index 000000000..1fe7b451f
--- /dev/null
+++ b/app/services/data_imports/intercom/source.rb
@@ -0,0 +1,181 @@
+class DataImports::Intercom::Source
+  PROVIDER = 'intercom'.freeze
+  DISPLAY_NAME = 'Intercom'.freeze
+  CONTACTS_PER_PAGE = 50
+  CONVERSATIONS_PER_PAGE = 10
+  ALREADY_IMPORTED_ERROR_CODE = 'DataImports::Intercom::AlreadyImported'.freeze
+  SKIPPED_MESSAGE_ERROR_CODE = 'DataImports::Intercom::SkippedMessage'.freeze
+  TRUNCATED_PARTS_ERROR_CODE = 'DataImports::Intercom::TruncatedConversationParts'.freeze
+
+  attr_reader :provider, :display_name, :contacts_per_page, :conversations_per_page
+
+  def self.credentials_validator(source_params:, import_types:)
+    DataImports::Intercom::CredentialsValidator.new(
+      access_token: source_params[:access_token],
+      import_types: import_types
+    )
+  end
+
+  def self.source_metadata(_source_params)
+    {}
+  end
+
+  def self.default_import_name
+    'Intercom import'
+  end
+
+  def self.credential_name
+    'access key'
+  end
+
+  def self.import_job_class
+    DataImports::Intercom::ImportJob
+  end
+
+  def self.importer_class
+    DataImports::Intercom::Importer
+  end
+
+  def self.contacts_page_job_class
+    DataImports::Intercom::ContactsPageJob
+  end
+
+  def self.conversations_page_job_class
+    DataImports::Intercom::ConversationsPageJob
+  end
+
+  def self.client_error?(error)
+    error.is_a?(DataImports::Intercom::Client::Error)
+  end
+
+  def self.authentication_error?(error)
+    error.is_a?(DataImports::Intercom::Client::AuthenticationError)
+  end
+
+  def initialize(access_token:, source_metadata: {}) # rubocop:disable Lint/UnusedMethodArgument
+    @provider = PROVIDER
+    @display_name = DISPLAY_NAME
+    @contacts_per_page = CONTACTS_PER_PAGE
+    @conversations_per_page = CONVERSATIONS_PER_PAGE
+    @client = DataImports::Intercom::Client.new(access_token: access_token)
+  end
+
+  def list_contacts(starting_after:, per_page:)
+    @client.list_contacts(starting_after: starting_after, per_page: per_page)
+  end
+
+  def list_conversations(starting_after:, per_page:)
+    @client.list_conversations(starting_after: starting_after, per_page: per_page)
+  end
+
+  def retrieve_conversation(id)
+    @client.retrieve_conversation(id)
+  end
+
+  def retrieve_contact(id)
+    @client.retrieve_contact(id)
+  end
+
+  def client_error?(error)
+    error.is_a?(DataImports::Intercom::Client::Error)
+  end
+
+  def placeholder_inbox_builder(account:)
+    DataImports::Intercom::PlaceholderInboxBuilder.new(account: account)
+  end
+
+  def message_batch_builder(data_import:, conversation:, source_conversation:)
+    DataImports::Intercom::MessageBatchBuilder.new(
+      data_import: data_import,
+      conversation: conversation,
+      source_conversation: source_conversation
+    )
+  end
+
+  def activity_part?(part)
+    DataImports::Intercom::MessageBatchBuilder.activity_part?(part)
+  end
+
+  def source_message_importable?(source)
+    DataImports::Intercom::MessageBatchBuilder.source_message_importable?(source)
+  end
+
+  def activity_content(part)
+    DataImports::Intercom::ActivityContentBuilder.new(part).perform
+  end
+
+  def already_imported_error_code
+    ALREADY_IMPORTED_ERROR_CODE
+  end
+
+  def skipped_message_error_code
+    SKIPPED_MESSAGE_ERROR_CODE
+  end
+
+  def truncated_parts_error_code
+    TRUNCATED_PARTS_ERROR_CODE
+  end
+
+  def skipped_message_reason
+    'blank_or_unsupported_intercom_part'
+  end
+
+  def contact_custom_attributes(contact_payload)
+    {
+      intercom_contact_id: contact_payload['id'],
+      intercom_external_id: contact_payload['external_id']
+    }.compact
+  end
+
+  def contact_source_metadata(contact_payload)
+    {
+      contact_id: contact_payload['id'],
+      external_id: contact_payload['external_id'],
+      raw_phone: contact_payload['phone']
+    }.compact
+  end
+
+  def conversation_custom_attributes(conversation)
+    { intercom_conversation_id: source_id_for(conversation) }
+  end
+
+  def conversation_source_metadata(conversation)
+    {
+      conversation_id: source_id_for(conversation),
+      delivered_as: conversation.dig('source', 'delivered_as'),
+      source_url: conversation.dig('source', 'url'),
+      admin_assignee_id: conversation['admin_assignee_id'],
+      team_assignee_id: conversation['team_assignee_id'],
+      state: conversation['state'],
+      open: conversation['open']
+    }.compact
+  end
+
+  def message_source_metadata(part)
+    {
+      part_id: part['id'],
+      part_type: part['part_type'],
+      author: part['author'],
+      assigned_to: part['assigned_to'],
+      state: part['state'],
+      tags: part['tags'],
+      event_details: part['event_details'],
+      app_package_code: part['app_package_code'],
+      metadata: part['metadata'],
+      attachments: part['attachments'],
+      redacted: part['redacted']
+    }.compact
+  end
+
+  def timestamp_for(value)
+    return Time.current if value.blank?
+
+    Time.zone.at(value.to_i)
+  end
+
+  private
+
+  def source_id_for(payload)
+    payload['id'].presence || payload['external_id'].presence || payload['email'].presence
+  end
+end
diff --git a/app/services/data_imports/message_batch_builder.rb b/app/services/data_imports/message_batch_builder.rb
new file mode 100644
index 000000000..d2c889473
--- /dev/null
+++ b/app/services/data_imports/message_batch_builder.rb
@@ -0,0 +1,144 @@
+class DataImports::MessageBatchBuilder
+  REGULAR_PART_TYPES = %w[comment note source].freeze
+
+  Entry = Struct.new(:source_id, :part, :position, :mapping, :message, :classification, keyword_init: true) do
+    def source?
+      part['part_type'] == 'source'
+    end
+  end
+
+  Batch = Struct.new(:items, keyword_init: true) do
+    def entries
+      items
+    end
+
+    def source_entries
+      items.select(&:source?)
+    end
+
+    def part_entries
+      items.reject(&:source?)
+    end
+  end
+
+  def self.activity_part?(part)
+    part_type = part['part_type'].to_s
+    part_type.present? && REGULAR_PART_TYPES.exclude?(part_type)
+  end
+
+  def self.source_message_importable?(source)
+    source['body'].present? || source['subject'].present? || source['attachments'].present?
+  end
+
+  def initialize(data_import:, conversation:, source_conversation:, provider:)
+    @data_import = data_import
+    @account = data_import.account
+    @conversation = conversation
+    @source_conversation = source_conversation
+    @provider = provider
+  end
+
+  def perform(source_entries = unprepared_entries)
+    classify(source_entries)
+  end
+
+  def refresh(entries)
+    classify(entries.map do |entry|
+      { source_id: entry.source_id, part: entry.part, position: entry.position }
+    end)
+  end
+
+  def unprepared_entries
+    ordered_source_entries.map.with_index { |entry, position| entry.merge(position: position) }
+  end
+
+  private
+
+  def classify(source_entries)
+    return Batch.new(items: []) if source_entries.empty?
+
+    mappings = message_mappings(source_entries)
+    messages = messages_for(source_entries, mappings)
+
+    Batch.new(items: source_entries.map.with_index do |source_entry, position|
+      build_entry(source_entry, source_entry.fetch(:position, position), mappings, messages)
+    end)
+  end
+
+  def ordered_source_entries
+    entries = []
+    source = @source_conversation['source'].to_h
+    if self.class.source_message_importable?(source)
+      entries << {
+        source_id: "conversation:#{source_conversation_id}:source:#{source['id'].presence || 'initial'}",
+        part: source.merge('part_type' => 'source', 'created_at' => @source_conversation['created_at'])
+      }
+    end
+
+    conversation_parts.each do |part|
+      entries << { source_id: "conversation:#{source_conversation_id}:part:#{part['id']}", part: part }
+    end
+    entries
+  end
+
+  def conversation_parts
+    Array(@source_conversation.dig('conversation_parts', 'conversation_parts'))
+  end
+
+  def source_conversation_id
+    @source_conversation['id'].presence || @source_conversation['external_id'].presence || @source_conversation['email'].presence
+  end
+
+  def message_mappings(source_entries)
+    DataImportMapping.where(
+      account: @account,
+      source_provider: @provider,
+      source_object_type: 'message',
+      source_object_id: source_entries.pluck(:source_id)
+    ).index_by(&:source_object_id)
+  end
+
+  def messages_for(source_entries, mappings)
+    mapped_message_ids = mappings.values.filter_map do |mapping|
+      mapping.chatwoot_record_id if mapping.chatwoot_record_type == 'Message'
+    end
+    chatwoot_source_ids = source_entries.map { |entry| "#{@provider}:#{entry[:source_id]}" }
+    messages = Message.where(id: mapped_message_ids).or(
+      Message.where(conversation_id: @conversation.id, source_id: chatwoot_source_ids)
+    ).to_a
+
+    {
+      by_id: messages.index_by(&:id),
+      by_source_id: messages.index_by(&:source_id)
+    }
+  end
+
+  def build_entry(source_entry, position, mappings, messages)
+    source_id = source_entry[:source_id]
+    mapping = mappings[source_id]
+    mapped_message = messages[:by_id][mapping.chatwoot_record_id] if mapping&.chatwoot_record_type == 'Message'
+    existing_message = messages[:by_source_id]["#{@provider}:#{source_id}"]
+
+    Entry.new(
+      source_id: source_id,
+      part: source_entry[:part],
+      position: position,
+      mapping: mapping,
+      message: mapped_message || existing_message,
+      classification: classification_for(mapping, mapped_message, existing_message, source_entry[:part])
+    )
+  end
+
+  def classification_for(mapping, mapped_message, existing_message, part)
+    return existing_message.present? ? :existing_message : :new_message if mapping.blank?
+    return :repairable_stale_mapping unless mapping_handled?(mapping, mapped_message, part)
+
+    mapping.data_import_id == @data_import.id ? :current_import : :previous_import
+  end
+
+  def mapping_handled?(mapping, mapped_message, part)
+    return false if mapping.metadata['skipped'] && self.class.activity_part?(part)
+
+    mapping.metadata['skipped'] || mapped_message.present?
+  end
+end
diff --git a/app/services/data_imports/placeholder_inbox_builder.rb b/app/services/data_imports/placeholder_inbox_builder.rb
new file mode 100644
index 000000000..1bf4758b3
--- /dev/null
+++ b/app/services/data_imports/placeholder_inbox_builder.rb
@@ -0,0 +1,65 @@
+class DataImports::PlaceholderInboxBuilder
+  AGENT_REPLY_TIME_WINDOW_HOURS = 1
+
+  def initialize(account:, provider:, source_bucket:)
+    @account = account
+    @provider = provider
+    @source_bucket = source_bucket
+  end
+
+  def inbox_for(source_type)
+    bucket = @source_bucket.for(source_type)
+    placeholder_inboxes[bucket[:key]] ||= create_placeholder_inbox(bucket)
+  end
+
+  private
+
+  def placeholder_inboxes
+    @placeholder_inboxes ||= @account.inboxes.includes(:channel).where(channel_type: 'Channel::Api').each_with_object({}) do |inbox, inboxes|
+      attrs = inbox.channel.additional_attributes || {}
+      next unless attrs['source_provider'] == @provider && attrs['import_placeholder'] == true
+
+      inboxes[attrs['source_bucket']] = inbox
+    end
+  end
+
+  def create_placeholder_inbox(bucket)
+    Inbox.transaction do
+      channel = create_placeholder_channel(bucket)
+      now = Time.current
+      result = Inbox.insert_all!( # rubocop:disable Rails/SkipsModelValidations
+        [placeholder_inbox_attributes(channel, bucket, now)],
+        returning: %w[id]
+      )
+      Inbox.find(result.rows.first.first).tap { |inbox| create_default_working_hours(inbox) }
+    end
+  end
+
+  def create_placeholder_channel(bucket)
+    @account.api_channels.create!(
+      additional_attributes: {
+        source_provider: @provider,
+        source_bucket: bucket[:key],
+        import_placeholder: true,
+        agent_reply_time_window: AGENT_REPLY_TIME_WINDOW_HOURS
+      }
+    )
+  end
+
+  def placeholder_inbox_attributes(channel, bucket, timestamp)
+    {
+      account_id: @account.id,
+      channel_id: channel.id,
+      channel_type: channel.class.name,
+      name: "#{@provider.titleize} Import - #{bucket[:name]}",
+      enable_auto_assignment: false,
+      allow_messages_after_resolved: false,
+      created_at: timestamp,
+      updated_at: timestamp
+    }
+  end
+
+  def create_default_working_hours(inbox)
+    OutOfOffisable::DEFAULT_WORKING_HOURS.each { |attributes| inbox.working_hours.create!(attributes) }
+  end
+end
diff --git a/app/services/data_imports/restart_service.rb b/app/services/data_imports/restart_service.rb
new file mode 100644
index 000000000..c3655fe9e
--- /dev/null
+++ b/app/services/data_imports/restart_service.rb
@@ -0,0 +1,56 @@
+class DataImports::RestartService
+  attr_reader :data_import
+
+  def initialize(account:, data_import:)
+    @account = account
+    @data_import = data_import
+  end
+
+  def perform
+    @account.with_lock do
+      @data_import.reload
+      next :render_show unless @data_import.integration_import?
+      next :render_show unless @data_import.restartable?
+
+      if (active_import = find_active_import)
+        @data_import = active_import
+        next :render_show
+      end
+
+      next :access_token_missing if @data_import.access_token.blank?
+
+      @data_import.assign_active_import_run_id
+      retained_skip_logs = @data_import.import_errors.where("details ->> 'kind' = ?", 'skipped')
+      @data_import.import_errors.where.not(id: retained_skip_logs.select(:id)).delete_all
+      @data_import.update!(restart_attributes(retained_skip_logs))
+      :enqueue
+    end
+  end
+
+  private
+
+  def find_active_import
+    @account.data_imports.active_integrations.first
+  end
+
+  def restart_attributes(retained_skip_logs)
+    {
+      status: :pending,
+      abandoned_at: nil,
+      completed_at: nil,
+      last_error_at: nil,
+      started_at: nil,
+      stats: restart_stats(retained_skip_logs)
+    }
+  end
+
+  def restart_stats(retained_skip_logs)
+    @data_import.stats.to_h.deep_dup.tap do |stats|
+      %w[contact conversation message].each do |object_type|
+        stats["#{object_type}s"] ||= {}
+        stats["#{object_type}s"]['skipped'] = retained_skip_logs.where(source_object_type: object_type).count
+      end
+      stats['errors'] = { 'count' => 0 }
+    end
+  end
+end
diff --git a/app/services/data_imports/retry_service.rb b/app/services/data_imports/retry_service.rb
new file mode 100644
index 000000000..91980a740
--- /dev/null
+++ b/app/services/data_imports/retry_service.rb
@@ -0,0 +1,28 @@
+class DataImports::RetryService
+  attr_reader :data_import
+
+  def initialize(account:, data_import:)
+    @account = account
+    @data_import = data_import
+  end
+
+  def perform
+    @account.with_lock do
+      @data_import.with_lock do
+        next :not_stalled unless @data_import.stalled?
+        next :active_import_exists if another_active_import?
+        next :access_token_missing if @data_import.access_token.blank?
+
+        @data_import.assign_active_import_run_id
+        @data_import.update!(status: :pending)
+        :enqueue
+      end
+    end
+  end
+
+  private
+
+  def another_active_import?
+    @account.data_imports.active_integrations.where.not(id: @data_import.id).exists?
+  end
+end
diff --git a/app/services/data_imports/source.rb b/app/services/data_imports/source.rb
new file mode 100644
index 000000000..496b3ce9d
--- /dev/null
+++ b/app/services/data_imports/source.rb
@@ -0,0 +1,21 @@
+class DataImports::Source
+  PROVIDERS = {
+    'freshdesk' => 'DataImports::Freshdesk::Source',
+    'intercom' => 'DataImports::Intercom::Source'
+  }.freeze
+
+  def self.for(data_import)
+    source_class(data_import.source_provider).new(
+      access_token: data_import.access_token,
+      source_metadata: data_import.source_metadata
+    )
+  end
+
+  def self.source_class(provider)
+    PROVIDERS.fetch(provider.to_s) { raise ArgumentError, 'Unsupported import source.' }.constantize
+  end
+
+  def self.supported?(provider)
+    PROVIDERS.key?(provider.to_s)
+  end
+end
diff --git a/lib/custom_exceptions/data_import/freshdesk_ticket_limit_error.rb b/lib/custom_exceptions/data_import/freshdesk_ticket_limit_error.rb
new file mode 100644
index 000000000..a5d59cc77
--- /dev/null
+++ b/lib/custom_exceptions/data_import/freshdesk_ticket_limit_error.rb
@@ -0,0 +1,13 @@
+class CustomExceptions::DataImport::FreshdeskTicketLimitError < CustomExceptions::Base
+  MESSAGE = 'Freshdesk limits ticket listing to 300 pages. This import stopped after 30,000 tickets because the API cannot ' \
+            'confirm that the ticket history is complete. A Freshdesk admin Account Export is required for any remaining history, ' \
+            'but this importer does not support account exports yet.'.freeze
+
+  def initialize
+    super({})
+  end
+
+  def message
+    MESSAGE
+  end
+end
diff --git a/spec/factories/data_import.rb b/spec/factories/data_import.rb
index ad361d237..567071bd7 100644
--- a/spec/factories/data_import.rb
+++ b/spec/factories/data_import.rb
@@ -12,5 +12,15 @@ FactoryBot.define do
       access_token { 'intercom-token' }
       import_file { nil }
     end
+
+    trait :freshdesk do
+      data_type { 'freshdesk' }
+      source_type { 'api' }
+      source_provider { 'freshdesk' }
+      import_types { %w[contacts conversations] }
+      access_token { 'freshdesk-api-key' }
+      source_metadata { { domain: 'acme.freshdesk.com' } }
+      import_file { nil }
+    end
   end
 end
diff --git a/spec/fixtures/data_import/freshdesk/README.md b/spec/fixtures/data_import/freshdesk/README.md
new file mode 100644
index 000000000..fa24b2f5c
--- /dev/null
+++ b/spec/fixtures/data_import/freshdesk/README.md
@@ -0,0 +1,22 @@
+# Freshdesk fixture provenance
+
+These fixtures contain no production credentials, signed attachment URLs, or
+personal data. Their field shapes were derived from the Freshdesk API v2
+documentation, sanitized examples in these public repositories, and a
+sanitized Freshdesk trial-account Web Chat response captured during live API
+validation:
+
+- [`Aaronontheweb/freshdesk-cli` ticket with conversations](https://github.com/Aaronontheweb/freshdesk-cli/blob/c87b74043a1662646378cd3385ec0db9af6fa28c/tests/TestData/FreshdeskResponses/ticket_with_conversations.json)
+- [`airbytehq/airbyte` Freshdesk expected records](https://github.com/airbytehq/airbyte/blob/0673d69418fe3874a6970d6113eec891db4a296b/airbyte-integrations/connectors/source-freshdesk/integration_tests/expected_records.jsonl)
+- [`pbrane/freshdesk-api-client` conversation fixture](https://github.com/pbrane/freshdesk-api-client/blob/c6685af0bf2da889b4a89ccb6cfeb53e65eb5575/src/main/resources/freshdesk/documents/tac-case-notes/tacCase99Conversations.json)
+- [`freshworks-developers/fw-attach` conversation event fixture](https://github.com/freshworks-developers/fw-attach/blob/45b7ea1ad6b9008b9edb73ecca349ee9d3b28a6d/server/test_data/support_ticket/onConversationCreate.json)
+
+The fixture intentionally covers an incoming ticket description, a public
+agent reply, a private note with attachment metadata, and a later customer
+reply.
+
+`web_chat_ticket_with_conversations.json` covers Freshdesk's current Web Chat
+ticket source (`15`), structured conversation bodies, the generated greeting,
+the initial customer message repeated in the ticket description, subsequent
+replies, and real attachment metadata keys. IDs, timestamps, addresses, names,
+content, and attachment URLs were replaced or removed.
diff --git a/spec/fixtures/data_import/freshdesk/contact.json b/spec/fixtures/data_import/freshdesk/contact.json
new file mode 100644
index 000000000..bc6af7f57
--- /dev/null
+++ b/spec/fixtures/data_import/freshdesk/contact.json
@@ -0,0 +1,20 @@
+{
+  "id": 1001,
+  "active": true,
+  "email": "customer@example.com",
+  "name": "Customer Example",
+  "mobile": "+15551234567",
+  "phone": null,
+  "created_at": "2024-01-01T09:00:00Z",
+  "updated_at": "2024-01-04T12:30:00Z",
+  "other_emails": [
+    "billing@example.com"
+  ],
+  "unique_external_id": "customer-1001",
+  "custom_fields": {
+    "support_plan": "growth"
+  },
+  "tags": [
+    "priority"
+  ]
+}
diff --git a/spec/fixtures/data_import/freshdesk/ticket_with_conversations.json b/spec/fixtures/data_import/freshdesk/ticket_with_conversations.json
new file mode 100644
index 000000000..fc9bff7dc
--- /dev/null
+++ b/spec/fixtures/data_import/freshdesk/ticket_with_conversations.json
@@ -0,0 +1,98 @@
+{
+  "ticket": {
+    "id": 2001,
+    "subject": "Unable to finish checkout",
+    "description": "<p>The checkout button is not responding.</p>",
+    "description_text": "The checkout button is not responding.",
+    "status": 4,
+    "priority": 2,
+    "source": 1,
+    "requester_id": 1001,
+    "responder_id": 501,
+    "group_id": 42,
+    "company_id": 77,
+    "tags": [
+      "checkout"
+    ],
+    "custom_fields": {
+      "product_area": "payments"
+    },
+    "created_at": "2024-01-02T10:00:00Z",
+    "updated_at": "2024-01-04T12:30:00Z",
+    "attachments": [],
+    "requester": {
+      "id": 1001,
+      "active": true,
+      "email": "customer@example.com",
+      "name": "Customer Example",
+      "mobile": "+15551234567",
+      "created_at": "2024-01-01T09:00:00Z",
+      "updated_at": "2024-01-04T12:30:00Z",
+      "unique_external_id": "customer-1001"
+    }
+  },
+  "conversations": [
+    {
+      "id": 3003,
+      "body": "<p>The issue still happens in a private window.</p>",
+      "body_text": "The issue still happens in a private window.",
+      "incoming": true,
+      "private": false,
+      "source": 0,
+      "user_id": 1001,
+      "from_email": "customer@example.com",
+      "to_emails": [
+        "support@example.com"
+      ],
+      "cc_emails": [],
+      "bcc_emails": [],
+      "created_at": "2024-01-04T12:30:00Z",
+      "updated_at": "2024-01-04T12:30:00Z",
+      "attachments": [],
+      "deleted": false
+    },
+    {
+      "id": 3001,
+      "body": "<p>Could you try this in a private window?</p>",
+      "body_text": "Could you try this in a private window?",
+      "incoming": false,
+      "private": false,
+      "source": 0,
+      "user_id": 501,
+      "from_email": "agent@example.com",
+      "to_emails": [
+        "customer@example.com"
+      ],
+      "cc_emails": [],
+      "bcc_emails": [],
+      "created_at": "2024-01-03T08:00:00Z",
+      "updated_at": "2024-01-03T08:00:00Z",
+      "attachments": [],
+      "deleted": false
+    },
+    {
+      "id": 3002,
+      "body": "<p>Payments team is investigating the browser logs.</p>",
+      "body_text": "Payments team is investigating the browser logs.",
+      "incoming": false,
+      "private": true,
+      "source": 2,
+      "user_id": 501,
+      "from_email": "agent@example.com",
+      "to_emails": [],
+      "cc_emails": [],
+      "bcc_emails": [],
+      "created_at": "2024-01-03T09:00:00Z",
+      "updated_at": "2024-01-03T09:00:00Z",
+      "attachments": [
+        {
+          "id": 4001,
+          "name": "browser-log.txt",
+          "content_type": "text/plain",
+          "size": 128
+        }
+      ],
+      "deleted": false
+    }
+  ]
+}
diff --git a/spec/fixtures/data_import/freshdesk/web_chat_ticket_with_conversations.json b/spec/fixtures/data_import/freshdesk/web_chat_ticket_with_conversations.json
new file mode 100644
index 000000000..508f85d96
--- /dev/null
+++ b/spec/fixtures/data_import/freshdesk/web_chat_ticket_with_conversations.json
@@ -0,0 +1,183 @@
+{
+  "ticket": {
+    "id": 2101,
+    "subject": "FD-IMPORT-WEBCHAT-002 — Brew temperature drops",
+    "description": "<div>Ticket Description: FD-IMPORT-WEBCHAT-002 — The brew temperature drops after three cups.</div>",
+    "description_text": "Ticket Description: FD-IMPORT-WEBCHAT-002 — The brew temperature drops after three cups.",
+    "status": 2,
+    "priority": 1,
+    "source": 15,
+    "source_info": 1,
+    "requester_id": 1101,
+    "responder_id": 510,
+    "group_id": null,
+    "company_id": null,
+    "tags": [],
+    "custom_fields": {},
+    "created_at": "2026-07-31T08:00:00Z",
+    "updated_at": "2026-07-31T08:10:00Z",
+    "attachments": [],
+    "requester": {
+      "id": 1101,
+      "email": null,
+      "name": "",
+      "mobile": null,
+      "phone": null
+    }
+  },
+  "conversations": [
+    {
+      "id": 3101,
+      "body": "<div>Hello! How can we help you today?</div>",
+      "body_text": "Hello! How can we help you today?",
+      "structured_body": {
+        "body_contents": [
+          {
+            "type": "text",
+            "data": {
+              "content": "Hello! How can we help you today?"
+            }
+          }
+        ]
+      },
+      "incoming": false,
+      "private": false,
+      "source": 15,
+      "category": 5,
+      "user_id": null,
+      "from_email": null,
+      "created_at": "2026-07-31T08:00:00Z",
+      "updated_at": "2026-07-31T08:00:00Z",
+      "attachments": []
+    },
+    {
+      "id": 3102,
+      "body": "<div>FD-IMPORT-WEBCHAT-002 — The brew temperature drops after three cups.</div>",
+      "body_text": "FD-IMPORT-WEBCHAT-002 — The brew temperature drops after three cups.",
+      "structured_body": {
+        "body_contents": [
+          {
+            "type": "text",
+            "data": {
+              "content": "FD-IMPORT-WEBCHAT-002 — The brew temperature drops after three cups."
+            }
+          }
+        ]
+      },
+      "incoming": true,
+      "private": false,
+      "source": 20,
+      "category": 1,
+      "user_id": 1101,
+      "from_email": null,
+      "created_at": "2026-07-31T08:00:01Z",
+      "updated_at": "2026-07-31T08:00:01Z",
+      "attachments": []
+    },
+    {
+      "id": 3103,
+      "body": "<div>The display reads 82°C instead of 93°C.</div>",
+      "body_text": "The display reads 82°C instead of 93°C.",
+      "structured_body": {
+        "body_contents": [
+          {
+            "type": "text",
+            "data": {
+              "content": "The display reads 82°C instead of 93°C."
+            }
+          }
+        ]
+      },
+      "incoming": true,
+      "private": false,
+      "source": 20,
+      "category": 1,
+      "user_id": 1101,
+      "from_email": null,
+      "created_at": "2026-07-31T08:01:00Z",
+      "updated_at": "2026-07-31T08:01:00Z",
+      "attachments": []
+    },
+    {
+      "id": 3104,
+      "body": "<div>Please run one rinse cycle, then check the next brew.</div>",
+      "body_text": "Please run one rinse cycle, then check the next brew.",
+      "structured_body": {
+        "body_contents": [
+          {
+            "type": "text",
+            "data": {
+              "content": "Please run one rinse cycle, then check the next brew."
+            }
+          }
+        ]
+      },
+      "incoming": false,
+      "private": false,
+      "source": 20,
+      "category": 3,
+      "user_id": 510,
+      "from_email": null,
+      "created_at": "2026-07-31T08:03:00Z",
+      "updated_at": "2026-07-31T08:03:00Z",
+      "attachments": []
+    },
+    {
+      "id": 3105,
+      "body": "<div>The next brew reached 89°C.</div>",
+      "body_text": "The next brew reached 89°C.",
+      "structured_body": {
+        "body_contents": [
+          {
+            "type": "text",
+            "data": {
+              "content": "The next brew reached 89°C."
+            }
+          }
+        ]
+      },
+      "incoming": true,
+      "private": false,
+      "source": 20,
+      "category": 1,
+      "user_id": 1101,
+      "from_email": null,
+      "created_at": "2026-07-31T08:05:00Z",
+      "updated_at": "2026-07-31T08:05:00Z",
+      "attachments": []
+    },
+    {
+      "id": 3106,
+      "body": "<div>Attached is a harmless text diagnostic.</div>",
+      "body_text": "Attached is a harmless text diagnostic.",
+      "structured_body": {
+        "body_contents": [
+          {
+            "type": "text",
+            "data": {
+              "content": "Attached is a harmless text diagnostic."
+            }
+          }
+        ]
+      },
+      "incoming": false,
+      "private": false,
+      "source": 20,
+      "category": 3,
+      "user_id": 510,
+      "from_email": "support@example.com",
+      "created_at": "2026-07-31T08:10:00Z",
+      "updated_at": "2026-07-31T08:10:00Z",
+      "attachments": [
+        {
+          "id": 4101,
+          "content_type": "text/plain",
+          "size": 188,
+          "name": "freshdesk-validation-diagnostic.txt",
+          "created_at": "2026-07-31T08:10:00Z",
+          "updated_at": "2026-07-31T08:10:00Z"
+        }
+      ]
+    }
+  ]
+}
diff --git a/spec/jobs/data_imports/freshdesk/import_jobs_spec.rb b/spec/jobs/data_imports/freshdesk/import_jobs_spec.rb
new file mode 100644
index 000000000..aa1831962
--- /dev/null
+++ b/spec/jobs/data_imports/freshdesk/import_jobs_spec.rb
@@ -0,0 +1,96 @@
+require 'rails_helper'
+
+RSpec.describe DataImports::Freshdesk::ImportJob do
+  let(:account) { create(:account) }
+  let(:data_import) { create(:data_import, :freshdesk, account: account) }
+  let(:importer) { instance_double(DataImports::Freshdesk::Importer) }
+  let(:run_id) { 'freshdesk-run-1' }
+
+  before do
+    account.enable_features!('data_import')
+    data_import.update!(source_metadata: data_import.source_metadata.merge(DataImport::ACTIVE_IMPORT_RUN_ID_KEY => run_id))
+    allow(DataImports::Freshdesk::Importer).to receive(:new).with(data_import: data_import, run_id: run_id).and_return(importer)
+  end
+
+  describe DataImports::Freshdesk::BaseJob do
+    it 'checks rate limit retry before the generic client retry' do
+      handlers = described_class.rescue_handlers.map(&:first)
+
+      expect(handlers.index('DataImports::Freshdesk::Client::RateLimitError')).to be > handlers.index('DataImports::Freshdesk::Client::Error')
+    end
+
+    it 'schedules a rate-limit retry using the Freshdesk Retry-After header' do
+      error = DataImports::Freshdesk::Client::RateLimitError.new('Rate limited', retry_after: '42')
+      allow(importer).to receive(:start!).and_raise(error)
+
+      travel_to(Time.zone.parse('2026-07-30 12:00:00 UTC')) do
+        expect do
+          DataImports::Freshdesk::ImportJob.perform_now(data_import, run_id)
+        end.to have_enqueued_job(DataImports::Freshdesk::ImportJob).at(42.seconds.from_now)
+      end
+    end
+
+    it 'discards a terminal ticket-limit error after recording the failed import' do
+      error = CustomExceptions::DataImport::FreshdeskTicketLimitError.new
+      allow(importer).to receive_messages(conversations_completed?: false, fail!: true)
+      allow(importer).to receive(:import_conversations_page).with(starting_after: nil).and_raise(error)
+
+      expect do
+        DataImports::Freshdesk::ConversationsPageJob.perform_now(data_import, nil, run_id)
+      end.not_to have_enqueued_job
+
+      expect(importer).to have_received(:fail!).with(error)
+    end
+  end
+
+  describe DataImports::Freshdesk::ImportJob do
+    it 'starts the import and enqueues the first contacts page' do
+      allow(importer).to receive_messages(start!: true, import_contacts?: true, contacts_completed?: false, cursor_for: 2)
+
+      expect do
+        described_class.perform_now(data_import, run_id)
+      end.to have_enqueued_job(DataImports::Freshdesk::ContactsPageJob).with(data_import, 2, run_id).on_queue('low')
+
+      expect(importer).to have_received(:start!)
+    end
+
+    it 'skips stale import jobs from an earlier run' do
+      data_import.update!(source_metadata: data_import.source_metadata.merge(DataImport::ACTIVE_IMPORT_RUN_ID_KEY => 'new-run'))
+
+      expect(DataImports::Freshdesk::Importer).not_to receive(:new)
+
+      described_class.perform_now(data_import, 'old-run')
+    end
+  end
+
+  describe DataImports::Freshdesk::ContactsPageJob do
+    it 'hands off to tickets after the final contacts page' do
+      result = DataImports::Freshdesk::Importer::PageResult.new(next_cursor: nil)
+      allow(importer).to receive_messages(
+        contacts_completed?: false,
+        import_conversations?: true,
+        conversations_completed?: false
+      )
+      allow(importer).to receive(:import_contacts_page).with(starting_after: nil).and_return(result)
+      allow(importer).to receive(:cursor_for).with('conversations').and_return(1)
+
+      expect do
+        described_class.perform_now(data_import, nil, run_id)
+      end.to have_enqueued_job(DataImports::Freshdesk::ConversationsPageJob).with(data_import, 1, run_id)
+    end
+  end
+
+  describe DataImports::Freshdesk::ConversationsPageJob do
+    it 'finishes after the final tickets page' do
+      result = DataImports::Freshdesk::Importer::PageResult.new(next_cursor: nil)
+      allow(importer).to receive_messages(conversations_completed?: false, finish!: true)
+      allow(importer).to receive(:import_conversations_page).with(starting_after: nil).and_return(result)
+
+      expect do
+        described_class.perform_now(data_import, nil, run_id)
+      end.not_to have_enqueued_job
+
+      expect(importer).to have_received(:finish!)
+    end
+  end
+end
diff --git a/spec/models/data_import_spec.rb b/spec/models/data_import_spec.rb
index 244d9f8d4..04cb39fb3 100644
--- a/spec/models/data_import_spec.rb
+++ b/spec/models/data_import_spec.rb
@@ -9,6 +9,13 @@ RSpec.describe DataImport do
     it 'returns false for invalid data type' do
       expect(build(:data_import, data_type: 'Xyc').valid?).to be false
     end
+
+    it 'requires an integration provider to match its data type' do
+      data_import = build(:data_import, :freshdesk, source_provider: 'intercom')
+
+      expect(data_import).not_to be_valid
+      expect(data_import.errors[:source_provider]).to include('must match the integration data type')
+    end
   end
 
   describe 'access token encryption' do
@@ -80,6 +87,13 @@ RSpec.describe DataImport do
       end
     end
 
+    it 'identifies stalled Freshdesk imports' do
+      freshdesk_import = create(:data_import, :freshdesk, account: account, status: :processing)
+      freshdesk_import.update!(updated_at: 15.minutes.ago)
+
+      expect(freshdesk_import.reload).to be_stalled
+    end
+
     it 'does not identify recent or terminal Intercom imports as stalled', :aggregate_failures do
       recent_import = create(:data_import, :intercom, account: account, status: :processing)
       completed_import = create(:data_import, :intercom, account: account, status: :completed)
diff --git a/spec/requests/api/v1/accounts/data_imports_spec.rb b/spec/requests/api/v1/accounts/data_imports_spec.rb
index 4ded7ff4a..78b5a5307 100644
--- a/spec/requests/api/v1/accounts/data_imports_spec.rb
+++ b/spec/requests/api/v1/accounts/data_imports_spec.rb
@@ -4,10 +4,12 @@ RSpec.describe 'Data Imports API', type: :request do
   let(:account) { create(:account) }
   let(:admin) { create(:user, account: account, role: :administrator) }
   let(:validator) { instance_double(DataImports::Intercom::CredentialsValidator, perform: { 'contacts' => 12, 'conversations' => 8 }) }
+  let(:freshdesk_validator) { instance_double(DataImports::Freshdesk::CredentialsValidator, perform: {}) }
 
   before do
     account.enable_features!('data_import')
     allow(DataImports::Intercom::CredentialsValidator).to receive(:new).and_return(validator)
+    allow(DataImports::Freshdesk::CredentialsValidator).to receive(:new).and_return(freshdesk_validator)
   end
 
   describe 'POST /api/v1/accounts/:account_id/data_imports/validate_source' do
@@ -37,6 +39,49 @@ RSpec.describe 'Data Imports API', type: :request do
         'message' => 'We could not validate this Intercom access key. Check the key and its permissions.'
       )
     end
+
+    it 'validates a Freshdesk domain and API key through its source adapter', :aggregate_failures do
+      post validate_source_api_v1_account_data_imports_url(account_id: account.id),
+           params: {
+             source_provider: 'freshdesk',
+             domain: 'acme.freshdesk.com',
+             access_token: 'freshdesk-api-key',
+             import_types: %w[contacts conversations]
+           },
+           headers: admin.create_new_auth_token,
+           as: :json
+
+      expect(response).to have_http_status(:ok)
+      expect(response.parsed_body).to eq('valid' => true, 'totals' => {})
+      expect(DataImports::Freshdesk::CredentialsValidator).to have_received(:new).with(
+        domain: 'acme.freshdesk.com',
+        api_key: 'freshdesk-api-key',
+        import_types: %w[contacts conversations]
+      )
+    end
+
+    it 'returns a safe Freshdesk authentication error' do
+      allow(freshdesk_validator).to receive(:perform).and_raise(
+        DataImports::Freshdesk::Client::AuthenticationError,
+        'provider response'
+      )
+
+      post validate_source_api_v1_account_data_imports_url(account_id: account.id),
+           params: {
+             source_provider: 'freshdesk',
+             domain: 'acme.freshdesk.com',
+             access_token: 'invalid',
+             import_types: %w[contacts]
+           },
+           headers: admin.create_new_auth_token,
+           as: :json
+
+      expect(response).to have_http_status(:unprocessable_entity)
+      expect(response.parsed_body).to eq(
+        'valid' => false,
+        'message' => 'We could not validate this Freshdesk API key. Check the key and its permissions.'
+      )
+    end
   end
 
   describe 'POST /api/v1/accounts/:account_id/data_imports' do
@@ -87,6 +132,36 @@ RSpec.describe 'Data Imports API', type: :request do
       expect(response.parsed_body).not_to have_key('access_token')
     end
 
+    it 'creates and enqueues a Freshdesk import', :aggregate_failures do
+      expect do
+        post api_v1_account_data_imports_url(account_id: account.id),
+             params: {
+               name: 'Freshdesk migration',
+               source_provider: 'freshdesk',
+               domain: 'https://ACME.freshdesk.com/support/home',
+               access_token: 'freshdesk-api-key',
+               import_types: %w[contacts conversations]
+             },
+             headers: admin.create_new_auth_token,
+             as: :json
+      end.to have_enqueued_job(DataImports::Freshdesk::ImportJob)
+
+      expect(response).to have_http_status(:ok)
+      data_import = account.data_imports.last
+      expect(data_import).to have_attributes(
+        name: 'Freshdesk migration',
+        data_type: 'freshdesk',
+        source_type: 'api',
+        source_provider: 'freshdesk',
+        initiated_by_id: admin.id
+      )
+      expect(data_import.access_token).to eq('freshdesk-api-key')
+      expect(data_import.source_metadata).to include('domain' => 'acme.freshdesk.com')
+      expect(data_import.active_import_run_id).to be_present
+      expect(response.parsed_body['source_provider']).to eq('freshdesk')
+      expect(response.parsed_body).not_to have_key('access_token')
+    end
+
     it 'rejects creation while another Intercom import is active' do
       active_import = create(
         :data_import, :intercom,
@@ -110,6 +185,26 @@ RSpec.describe 'Data Imports API', type: :request do
       expect(active_import.reload).to be_processing
     end
 
+    it 'rejects a Freshdesk import while another integration import is active' do
+      create(:data_import, :intercom, account: account, status: :processing)
+
+      expect do
+        post api_v1_account_data_imports_url(account_id: account.id),
+             params: {
+               source_provider: 'freshdesk',
+               domain: 'acme.freshdesk.com',
+               access_token: 'freshdesk-api-key',
+               import_types: %w[contacts conversations]
+             },
+             headers: admin.create_new_auth_token,
+             as: :json
+      end.not_to have_enqueued_job(DataImports::Freshdesk::ImportJob)
+
+      expect(response).to have_http_status(:unprocessable_entity)
+      expect(response.parsed_body['message']).to eq('Another data import is already in progress.')
+      expect(account.data_imports.where(source_provider: 'freshdesk')).to be_empty
+    end
+
     it 'rejects unsupported import types instead of silently importing everything' do
       allow(validator).to receive(:perform).and_raise(ArgumentError, 'Unsupported import types: companies')
 
@@ -207,6 +302,20 @@ RSpec.describe 'Data Imports API', type: :request do
       expect(response.parsed_body['message']).to eq('The Intercom access key for this import is unavailable.')
       expect(data_import.reload).to be_abandoned
     end
+
+    it 'restarts an abandoned Freshdesk import with the Freshdesk job' do
+      freshdesk_import = create(:data_import, :freshdesk, account: account, status: :abandoned, abandoned_at: 1.hour.ago)
+
+      expect do
+        post start_api_v1_account_data_import_url(account_id: account.id, id: freshdesk_import.id),
+             headers: admin.create_new_auth_token,
+             as: :json
+      end.to have_enqueued_job(DataImports::Freshdesk::ImportJob).with(freshdesk_import, a_kind_of(String))
+
+      expect(response).to have_http_status(:ok)
+      expect(freshdesk_import.reload).to be_pending
+      expect(freshdesk_import.active_import_run_id).to be_present
+    end
   end
 
   describe 'POST /api/v1/accounts/:account_id/data_imports/:id/retry' do
@@ -264,6 +373,20 @@ RSpec.describe 'Data Imports API', type: :request do
       expect(response).to have_http_status(:unprocessable_entity)
       expect(response.parsed_body['message']).to eq('Another Intercom import is already in progress.')
     end
+
+    it 'resumes a stalled Freshdesk import with the Freshdesk job' do
+      freshdesk_import = create(:data_import, :freshdesk, account: account, status: :processing, started_at: 2.hours.ago)
+      freshdesk_import.update!(updated_at: 16.minutes.ago)
+
+      expect do
+        post retry_api_v1_account_data_import_url(account_id: account.id, id: freshdesk_import.id),
+             headers: admin.create_new_auth_token,
+             as: :json
+      end.to have_enqueued_job(DataImports::Freshdesk::ImportJob).with(freshdesk_import, a_kind_of(String))
+
+      expect(response).to have_http_status(:ok)
+      expect(freshdesk_import.reload).to be_pending
+    end
   end
 
   describe 'POST /api/v1/accounts/:account_id/data_imports/:id/abandon' do
diff --git a/spec/services/data_imports/freshdesk/client_spec.rb b/spec/services/data_imports/freshdesk/client_spec.rb
new file mode 100644
index 000000000..28c290861
--- /dev/null
+++ b/spec/services/data_imports/freshdesk/client_spec.rb
@@ -0,0 +1,90 @@
+require 'rails_helper'
+
+RSpec.describe DataImports::Freshdesk::Client do
+  describe '.normalize_domain' do
+    it 'accepts a Freshdesk subdomain, hostname, or URL', :aggregate_failures do
+      expect(described_class.normalize_domain('acme')).to eq('acme.freshdesk.com')
+      expect(described_class.normalize_domain('ACME.FRESHDESK.COM')).to eq('acme.freshdesk.com')
+      expect(described_class.normalize_domain('https://acme.freshdesk.com/support/home')).to eq('acme.freshdesk.com')
+    end
+
+    it 'rejects hosts outside Freshdesk' do
+      expect do
+        described_class.normalize_domain('acme.example.com')
+      end.to raise_error(ArgumentError, 'Enter a valid Freshdesk domain, such as acme.freshdesk.com.')
+    end
+  end
+
+  describe '#list_tickets' do
+    it 'uses API key basic authentication, requests full history, and follows the next page link', :aggregate_failures do
+      response = instance_double(
+        HTTParty::Response,
+        success?: true,
+        code: 200,
+        parsed_response: [{ 'id' => 2001 }],
+        headers: {
+          'link' => '<https://acme.freshdesk.com/api/v2/tickets?page=3&per_page=100>; rel="next"'
+        }
+      )
+      allow(HTTParty).to receive(:get).and_return(response)
+
+      page = described_class.new(domain: 'acme', api_key: 'secret').list_tickets(page: 2)
+
+      expect(HTTParty).to have_received(:get).with(
+        'https://acme.freshdesk.com/api/v2/tickets',
+        query: {
+          page: 2,
+          per_page: 100,
+          updated_since: DataImports::Freshdesk::Client::EARLIEST_TICKET_TIMESTAMP
+        },
+        basic_auth: { username: 'secret', password: 'X' },
+        headers: { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+        timeout: 30
+      )
+      expect(page.data).to eq([{ 'id' => 2001 }])
+      expect(page.next_page).to eq(3)
+    end
+
+    it 'accepts only forward pages from relative or same-domain links', :aggregate_failures do
+      client = described_class.new(domain: 'acme', api_key: 'secret')
+
+      expect(client.send(:next_page, '</api/v2/tickets?page=3>; rel="next"', current_page: 2)).to eq(3)
+      expect(client.send(:next_page, '<https://acme.freshdesk.com/api/v2/tickets?page=4>; rel="next"', current_page: 3)).to eq(4)
+      expect(client.send(:next_page, '<https://other.freshdesk.com/api/v2/tickets?page=4>; rel="next"', current_page: 3)).to be_nil
+      expect(client.send(:next_page, '</api/v2/tickets?page=abc>; rel="next"', current_page: 2)).to be_nil
+      expect(client.send(:next_page, '</api/v2/tickets?page=0>; rel="next"', current_page: 2)).to be_nil
+      expect(client.send(:next_page, '</api/v2/tickets?page=2>; rel="next"', current_page: 2)).to be_nil
+      expect(client.send(:next_page, '</api/v2/tickets?page=1>; rel="next"', current_page: 2)).to be_nil
+      expect(client.send(:next_page, '<%%%>; rel="next"', current_page: 2)).to be_nil
+    end
+  end
+
+  describe 'errors' do
+    it 'exposes Freshdesk retry timing on rate limits', :aggregate_failures do
+      response = instance_double(
+        HTTParty::Response,
+        success?: false,
+        code: 429,
+        parsed_response: { 'description' => 'Rate limit exceeded' },
+        headers: { 'retry-after' => '42' }
+      )
+      allow(HTTParty).to receive(:get).and_return(response)
+
+      expect { described_class.new(domain: 'acme', api_key: 'secret').list_contacts }.to raise_error do |error|
+        expect(error.class.name).to eq('DataImports::Freshdesk::Client::RateLimitError')
+        expect(error).to have_attributes(status: 429, retry_after: '42')
+        expect(error.message).to eq('Rate limit exceeded')
+      end
+    end
+
+    it 'wraps transport failures in a retryable client error', :aggregate_failures do
+      allow(HTTParty).to receive(:get).and_raise(SocketError, 'getaddrinfo failed')
+
+      expect { described_class.new(domain: 'acme', api_key: 'secret').list_contacts }.to raise_error do |error|
+        expect(error.class.name).to eq('DataImports::Freshdesk::Client::Error')
+        expect(error.message).to eq('Freshdesk API request failed before receiving a response: getaddrinfo failed')
+        expect(error.body).to include(transport_error_class: 'SocketError')
+      end
+    end
+  end
+end
diff --git a/spec/services/data_imports/freshdesk/credentials_validator_spec.rb b/spec/services/data_imports/freshdesk/credentials_validator_spec.rb
new file mode 100644
index 000000000..6235a6f42
--- /dev/null
+++ b/spec/services/data_imports/freshdesk/credentials_validator_spec.rb
@@ -0,0 +1,39 @@
+require 'rails_helper'
+
+RSpec.describe DataImports::Freshdesk::CredentialsValidator do
+  let(:client) { instance_double(DataImports::Freshdesk::Client) }
+
+  before do
+    allow(DataImports::Freshdesk::Client).to receive(:new).with(domain: 'acme', api_key: 'secret').and_return(client)
+    allow(client).to receive(:list_contacts)
+    allow(client).to receive(:list_tickets)
+  end
+
+  it 'validates only the selected Freshdesk resources and leaves totals undiscovered', :aggregate_failures do
+    totals = described_class.new(domain: 'acme', api_key: ' secret ', import_types: %w[conversations]).perform
+
+    expect(totals).to be_empty
+    expect(client).to have_received(:list_tickets).with(per_page: 1)
+    expect(client).not_to have_received(:list_contacts)
+  end
+
+  it 'validates contacts and tickets when both are selected', :aggregate_failures do
+    described_class.new(domain: 'acme', api_key: 'secret', import_types: %w[contacts conversations]).perform
+
+    expect(client).to have_received(:list_contacts).with(per_page: 1)
+    expect(client).to have_received(:list_tickets).with(per_page: 1)
+  end
+
+  it 'rejects missing or unsupported input before calling Freshdesk', :aggregate_failures do
+    expect do
+      described_class.new(domain: '', api_key: 'secret', import_types: %w[contacts]).perform
+    end.to raise_error(ArgumentError, 'Freshdesk domain is required.')
+    expect do
+      described_class.new(domain: 'acme', api_key: '', import_types: %w[contacts]).perform
+    end.to raise_error(ArgumentError, 'Freshdesk API key is required.')
+    expect do
+      described_class.new(domain: 'acme', api_key: 'secret', import_types: %w[companies]).perform
+    end.to raise_error(ArgumentError, 'Unsupported import types: companies')
+    expect(DataImports::Freshdesk::Client).not_to have_received(:new)
+  end
+end
diff --git a/spec/services/data_imports/freshdesk/importer_spec.rb b/spec/services/data_imports/freshdesk/importer_spec.rb
new file mode 100644
index 000000000..c1ec98b4a
--- /dev/null
+++ b/spec/services/data_imports/freshdesk/importer_spec.rb
@@ -0,0 +1,302 @@
+require 'rails_helper'
+require 'timeout'
+
+RSpec.describe DataImports::Freshdesk::Importer do
+  let(:account) { create(:account) }
+  let(:data_import) { create(:data_import, :freshdesk, account: account) }
+  let(:client) { instance_double(DataImports::Freshdesk::Client) }
+  let(:contact_payload) do
+    JSON.parse(Rails.root.join('spec/fixtures/data_import/freshdesk/contact.json').read)
+  end
+  let(:ticket_fixture) do
+    JSON.parse(Rails.root.join('spec/fixtures/data_import/freshdesk/ticket_with_conversations.json').read)
+  end
+
+  before do
+    account.enable_features!('data_import')
+    allow(DataImports::Freshdesk::Client).to receive(:new).with(
+      domain: 'acme.freshdesk.com',
+      api_key: 'freshdesk-api-key'
+    ).and_return(client)
+    allow(client).to receive(:list_contacts).with(page: 1, per_page: 100).and_return(
+      DataImports::Freshdesk::Client::Page.new(data: [contact_payload], next_page: nil)
+    )
+    allow(client).to receive(:list_tickets).with(page: 1, per_page: 100).and_return(
+      DataImports::Freshdesk::Client::Page.new(data: [ticket_fixture.fetch('ticket')], next_page: nil)
+    )
+    allow(client).to receive(:retrieve_ticket).with('2001').and_return(ticket_fixture.fetch('ticket'))
+    allow(client).to receive(:list_conversations).with('2001', page: 1, per_page: 100).and_return(
+      DataImports::Freshdesk::Client::Page.new(data: ticket_fixture.fetch('conversations'), next_page: nil)
+    )
+  end
+
+  it 'imports Freshdesk contacts, tickets, replies, and private notes through the shared importer', :aggregate_failures do
+    described_class.new(data_import: data_import).perform
+
+    contact = account.contacts.find_by!(email: 'customer@example.com')
+    expect(contact).to have_attributes(
+      name: 'Customer Example',
+      phone_number: '+15551234567',
+      identifier: 'customer-1001'
+    )
+    expect(contact.custom_attributes).to include(
+      'freshdesk_contact_id' => '1001',
+      'freshdesk_unique_external_id' => 'customer-1001'
+    )
+
+    inbox = account.inboxes.find_by!(name: 'Freshdesk Import - Email')
+    expect(inbox.channel.additional_attributes).to include(
+      'source_provider' => 'freshdesk',
+      'source_bucket' => 'email',
+      'import_placeholder' => true
+    )
+
+    conversation = account.conversations.find_by!(identifier: 'freshdesk:2001')
+    expect(conversation).to have_attributes(
+      status: 'resolved',
+      inbox_id: inbox.id,
+      contact_id: contact.id
+    )
+    expect(conversation.custom_attributes).to include(
+      'freshdesk_ticket_id' => '2001',
+      'freshdesk_status' => 4,
+      'freshdesk_priority' => 2
+    )
+
+    messages = conversation.messages.order(:created_at, :id)
+    expect(messages.pluck(:content)).to eq(
+      [
+        "Unable to finish checkout\n\nThe checkout button is not responding.",
+        'Could you try this in a private window?',
+        "Payments team is investigating the browser logs.\n\n[Freshdesk attachment skipped: 1]",
+        'The issue still happens in a private window.'
+      ]
+    )
+    expect(messages.map(&:message_type)).to eq(%w[incoming outgoing outgoing incoming])
+    expect(messages.pluck(:private)).to eq([false, false, true, false])
+    expect(messages.third.additional_attributes.dig('source', 'conversation_source')).to eq(2)
+    expect(messages.third.additional_attributes.dig('source', 'attachments', 0, 'name')).to eq('browser-log.txt')
+
+    expect(data_import.reload).to be_completed
+    expect(data_import.stats).to include(
+      'contacts' => include('imported' => 1, 'skipped' => 0),
+      'conversations' => include('imported' => 1, 'skipped' => 0),
+      'messages' => include('imported' => 4, 'skipped' => 0, 'total' => 4),
+      'errors' => { 'count' => 0 }
+    )
+    expect(data_import.processed_records).to eq(6)
+    expect(data_import.mappings.count).to eq(6)
+  end
+
+  it 'preserves the contact that authored an incoming reply' do
+    conversations = ticket_fixture.fetch('conversations').map(&:deep_dup)
+    conversations.first.merge!('user_id' => 1002, 'from_email' => 'cc@example.com')
+    allow(client).to receive(:list_conversations).with('2001', page: 1, per_page: 100).and_return(
+      DataImports::Freshdesk::Client::Page.new(data: conversations, next_page: nil)
+    )
+    data_import.update!(import_types: ['conversations'])
+
+    described_class.new(data_import: data_import).perform
+
+    reply = account.conversations.find_by!(identifier: 'freshdesk:2001').messages.find_by!(content: 'The issue still happens in a private window.')
+    expect(reply.sender).to have_attributes(email: 'cc@example.com')
+    expect(reply.sender_id).not_to eq(reply.conversation.contact_id)
+  end
+
+  it 'preserves newer progress when a delayed worker persists a stale snapshot', :aggregate_failures do
+    data_import.update!(
+      status: :processing,
+      cursor: { 'contacts' => { 'starting_after' => 'cursor-1', 'completed' => false } },
+      stats: {
+        'contacts' => { 'total' => 4, 'imported' => 1, 'skipped' => 0 },
+        'conversations' => { 'imported' => 0, 'skipped' => 0 },
+        'messages' => { 'imported' => 0, 'skipped' => 0 },
+        'errors' => { 'count' => 0 }
+      },
+      processed_records: 1
+    )
+    data_import.items.create!(
+      source_provider: 'freshdesk', source_object_type: 'contact', source_object_id: '1001', status: :imported
+    )
+    delayed_importer = described_class.new(data_import: DataImport.find(data_import.id))
+
+    data_import.items.create!(
+      source_provider: 'freshdesk', source_object_type: 'contact', source_object_id: '1002', status: :imported
+    )
+    data_import.reload.update!(
+      cursor: { 'contacts' => { 'starting_after' => 'cursor-2', 'completed' => false } },
+      stats: data_import.stats.deep_merge('contacts' => { 'imported' => 2 }),
+      processed_records: 2
+    )
+
+    delayed_importer.send(:persist_stats)
+    expect(delayed_importer.send(:update_cursor, 'contacts', 'cursor-1')).to eq('cursor-2')
+
+    expect(data_import.reload.cursor.dig('contacts', 'starting_after')).to eq('cursor-2')
+    expect(data_import.stats.dig('contacts', 'imported')).to eq(2)
+    expect(data_import.processed_records).to eq(2)
+  end
+
+  it 'does not let an old import run overwrite its replacement cursor', :aggregate_failures do
+    data_import.update!(
+      status: :processing,
+      source_metadata: data_import.source_metadata.merge('active_import_run_id' => 'run-1'),
+      cursor: { 'conversations' => { 'starting_after' => { 'page' => 1, 'offset' => 0 }, 'completed' => false } }
+    )
+    delayed_importer = described_class.new(data_import: DataImport.find(data_import.id), run_id: 'run-1')
+    replacement_cursor = { 'page' => 1, 'offset' => 3 }
+    data_import.reload.update!(
+      source_metadata: data_import.source_metadata.merge('active_import_run_id' => 'run-2'),
+      cursor: { 'conversations' => { 'starting_after' => replacement_cursor, 'completed' => false } }
+    )
+
+    result = delayed_importer.send(:update_cursor, 'conversations', { 'page' => 1, 'offset' => 1 })
+
+    expect(result).to eq(replacement_cursor)
+    expect(data_import.reload.cursor.dig('conversations', 'starting_after')).to eq(replacement_cursor)
+    expect(delayed_importer.send(:import_stopped?)).to be(true)
+  end
+
+  it 'serializes overlapping workers importing the same conversation', :aggregate_failures do
+    started_requests = Queue.new
+    release_requests = Queue.new
+    allow(client).to receive(:retrieve_ticket).with('2001') do
+      started_requests << true
+      release_requests.pop
+      ticket_fixture.fetch('ticket')
+    end
+    importers = Array.new(2) { described_class.new(data_import: DataImport.find(data_import.id)) }
+    errors = Concurrent::Array.new
+    conversation_summary = { 'id' => '2001', 'source' => { 'type' => 'email' } }
+    threads = importers.map do |importer|
+      Thread.new do
+        importer.send(:import_conversation_from_summary, conversation_summary)
+      rescue StandardError => e
+        errors << e
+      end
+    end
+
+    begin
+      2.times { Timeout.timeout(5) { started_requests.pop } }
+    ensure
+      2.times { release_requests << true }
+      threads.each { |thread| thread.join(10) }
+    end
+
+    expect(threads).to all(satisfy { |thread| !thread.alive? })
+    expect(errors).to be_empty
+    expect(account.conversations.where(identifier: 'freshdesk:2001').count).to eq(1)
+    expect(account.messages.count).to eq(4)
+    expect(data_import.mappings.count).to eq(6)
+    expect(data_import.items.find_by!(source_object_type: 'conversation', source_object_id: '2001')).to have_attributes(
+      status: 'imported', attempt_count: 2
+    )
+  end
+
+  it 'recognizes a structured cursor after JSON persistence' do
+    importer = described_class.new(data_import: data_import)
+
+    importer.send(:update_cursor, 'conversations', { page: 1, offset: 2 })
+    data_import.reload
+    importer.send(:update_cursor, 'conversations', nil)
+
+    expect(data_import.reload.cursor['conversations']).to include('starting_after' => nil, 'completed' => true)
+  end
+
+  it 'resumes a rate-limited ticket chunk from the last persisted checkpoint', :aggregate_failures do
+    tickets = Array.new(3) { |index| { 'id' => index + 2001, 'source' => 1 } }
+    allow(client).to receive(:list_tickets).with(page: 1, per_page: 100).and_return(
+      DataImports::Freshdesk::Client::Page.new(data: tickets, next_page: nil)
+    )
+    importer = described_class.new(data_import: data_import)
+    processed_ticket_ids = []
+    rate_limited = true
+    allow(importer).to receive(:import_conversation_from_summary) do |summary|
+      processed_ticket_ids << summary['id']
+      if summary['id'] == '2003' && rate_limited
+        rate_limited = false
+        raise DataImports::Freshdesk::Client::RateLimitError.new('Rate limited', retry_after: '42')
+      end
+    end
+
+    expect do
+      importer.import_conversations_page(starting_after: { 'page' => 1, 'offset' => 0 })
+    end.to raise_error(DataImports::Freshdesk::Client::RateLimitError)
+    expect(processed_ticket_ids).to eq(%w[2001 2002 2003])
+    expect(data_import.reload.cursor.dig('conversations', 'starting_after')).to include('page' => 1, 'offset' => 2)
+
+    processed_ticket_ids.clear
+    result = importer.import_conversations_page(starting_after: { 'page' => 1, 'offset' => 0 })
+
+    expect(processed_ticket_ids).to eq(%w[2003])
+    expect(result).to be_done
+    expect(data_import.reload.cursor['conversations']).to include('starting_after' => nil, 'completed' => true)
+    expect(client).to have_received(:list_tickets).once
+  end
+
+  it 'stops a delayed worker when a newer per-ticket checkpoint is observed', :aggregate_failures do
+    current_cursor = { 'page' => 1, 'offset' => 0, 'tickets' => [], 'next_page' => 2 }
+    newer_cursor = current_cursor.merge('offset' => 3)
+    summaries = Array.new(3) { |index| { 'id' => (index + 2001).to_s } }
+    response = {
+      'data' => summaries,
+      'pages' => {
+        'current' => { 'starting_after' => current_cursor },
+        'next' => { 'starting_after' => { 'page' => 2, 'offset' => 0 } },
+        'checkpoints' => Array.new(3) { |index| current_cursor.merge('offset' => index + 1) }
+      }
+    }
+    importer = described_class.new(data_import: DataImport.find(data_import.id))
+    allow(importer).to receive(:conversations_page).and_return(response)
+    cursor_advanced = false
+    allow(importer).to receive(:persist_stats).and_wrap_original do |method, *args|
+      method.call(*args)
+      next if cursor_advanced
+
+      cursor_advanced = true
+      concurrent_import = DataImport.find(data_import.id)
+      concurrent_import.update!(
+        cursor: concurrent_import.cursor.to_h.deep_merge(
+          'conversations' => { 'starting_after' => newer_cursor, 'completed' => false }
+        )
+      )
+    end
+
+    result = importer.import_conversations_page(starting_after: current_cursor)
+
+    expect(account.conversations.where(identifier: 'freshdesk:2001').count).to eq(1)
+    expect(client).not_to have_received(:retrieve_ticket).with('2002')
+    expect(result.next_cursor).to eq(newer_cursor)
+    expect(data_import.reload.cursor.dig('conversations', 'starting_after')).to eq(newer_cursor)
+  end
+
+  it 'fails with an actionable error instead of completing at the REST ticket limit', :aggregate_failures do
+    tickets = Array.new(100) { |index| { 'id' => index + 1, 'source' => 1 } }
+    allow(client).to receive(:list_tickets).with(page: 300, per_page: 100).and_return(
+      DataImports::Freshdesk::Client::Page.new(data: tickets, next_page: nil)
+    )
+    importer = described_class.new(data_import: data_import)
+    processed_ticket_ids = []
+    allow(importer).to receive(:import_conversation_from_summary) { |summary| processed_ticket_ids << summary['id'] }
+    limit_error = nil
+
+    expect { importer.import_conversations_page(starting_after: { 'page' => 300, 'offset' => 90 }) }.to raise_error do |error|
+      expect(error.class.name).to eq('CustomExceptions::DataImport::FreshdeskTicketLimitError')
+      limit_error = error
+    end
+    importer.fail!(limit_error)
+
+    expect(processed_ticket_ids).to eq((91..100).map(&:to_s))
+    expect(data_import.reload).to be_failed
+    expect(data_import.cursor.dig('conversations', 'starting_after')).to include('page' => 300, 'offset' => 99)
+    expect(data_import.import_errors.last).to have_attributes(
+      error_code: 'CustomExceptions::DataImport::FreshdeskTicketLimitError',
+      message: limit_error.message
+    )
+    expect(data_import.import_errors.last.details).to include(
+      'kind' => 'run_error',
+      'source_provider' => 'freshdesk',
+      'error_class' => 'CustomExceptions::DataImport::FreshdeskTicketLimitError'
+    )
+  end
+end
diff --git a/spec/services/data_imports/freshdesk/normalizer_spec.rb b/spec/services/data_imports/freshdesk/normalizer_spec.rb
new file mode 100644
index 000000000..ad1020d18
--- /dev/null
+++ b/spec/services/data_imports/freshdesk/normalizer_spec.rb
@@ -0,0 +1,106 @@
+require 'rails_helper'
+
+RSpec.describe DataImports::Freshdesk::Normalizer do
+  let(:contact_payload) do
+    JSON.parse(Rails.root.join('spec/fixtures/data_import/freshdesk/contact.json').read)
+  end
+  let(:ticket_fixture) do
+    JSON.parse(Rails.root.join('spec/fixtures/data_import/freshdesk/ticket_with_conversations.json').read)
+  end
+  let(:web_chat_fixture) do
+    JSON.parse(Rails.root.join('spec/fixtures/data_import/freshdesk/web_chat_ticket_with_conversations.json').read)
+  end
+
+  it 'normalizes Freshdesk contacts into the shared importer contract', :aggregate_failures do
+    contact = described_class.new.contact(contact_payload)
+
+    expect(contact).to include(
+      'id' => '1001',
+      'name' => 'Customer Example',
+      'email' => 'customer@example.com',
+      'phone' => '+15551234567',
+      'external_id' => 'customer-1001',
+      'other_emails' => ['billing@example.com'],
+      'custom_fields' => { 'support_plan' => 'growth' },
+      'tags' => ['priority']
+    )
+    expect(contact['created_at']).to eq(Time.zone.parse('2024-01-01T09:00:00Z').to_i)
+    expect(contact['updated_at']).to eq(Time.zone.parse('2024-01-04T12:30:00Z').to_i)
+  end
+
+  it 'normalizes ticket descriptions, replies, and private notes in source order', :aggregate_failures do
+    ticket = described_class.new.ticket(ticket_fixture.fetch('ticket'), ticket_fixture.fetch('conversations'))
+    parts = ticket.dig('conversation_parts', 'conversation_parts')
+
+    expect(ticket).to include(
+      'id' => '2001',
+      'status' => 4,
+      'priority' => 2,
+      'requester_id' => 1001
+    )
+    expect(ticket.dig('source', 'type')).to eq('email')
+    expect(ticket.dig('source', 'author', 'type')).to eq('contact')
+    expect(ticket.dig('contacts', 'contacts', 0, 'email')).to eq('customer@example.com')
+    expect(parts.pluck('id')).to eq(%w[3001 3002 3003])
+    expect(parts.pluck('part_type')).to eq(%w[comment note comment])
+    expect(parts.map { |part| part.dig('author', 'type') }).to eq(%w[admin admin contact])
+    expect(parts.second).to include('private' => true)
+    expect(parts.second['attachments'].first).to include('name' => 'browser-log.txt')
+  end
+
+  it 'preserves provider order for messages with equal timestamps' do
+    conversations = ticket_fixture.fetch('conversations').map(&:deep_dup)
+    conversations[0]['created_at'] = conversations[1]['created_at']
+
+    ticket = described_class.new.ticket(ticket_fixture.fetch('ticket'), conversations)
+
+    expect(ticket.dig('conversation_parts', 'conversation_parts').pluck('id')).to eq(%w[3003 3001 3002])
+  end
+
+  it 'includes incoming reply authors as conversation contacts' do
+    conversations = ticket_fixture.fetch('conversations').map(&:deep_dup)
+    conversations.first.merge!('user_id' => 1002, 'from_email' => 'cc@example.com')
+
+    ticket = described_class.new.ticket(ticket_fixture.fetch('ticket'), conversations)
+
+    expect(ticket.dig('contacts', 'contacts')).to include(
+      include('id' => '1001', 'email' => 'customer@example.com'),
+      include('id' => '1002', 'email' => 'cc@example.com')
+    )
+    expect(ticket.dig('conversation_parts', 'conversation_parts').last['author']).to include(
+      'id' => '1002', 'email' => 'cc@example.com'
+    )
+  end
+
+  it 'marks outbound email ticket descriptions as outgoing source messages' do
+    outbound_ticket = ticket_fixture.fetch('ticket').merge('source' => 10)
+
+    ticket = described_class.new.ticket(outbound_ticket, [])
+
+    expect(ticket.dig('source', 'type')).to eq('outbound_email')
+    expect(ticket.dig('source', 'author', 'type')).to eq('admin')
+  end
+
+  it 'uses Web Chat conversation events as the complete message history', :aggregate_failures do
+    ticket = described_class.new.ticket(web_chat_fixture.fetch('ticket'), web_chat_fixture.fetch('conversations'))
+    parts = ticket.dig('conversation_parts', 'conversation_parts')
+
+    expect(ticket).to include(
+      'id' => '2101',
+      'subject' => 'FD-IMPORT-WEBCHAT-002 — Brew temperature drops',
+      'status' => 2,
+      'priority' => 1
+    )
+    expect(ticket.dig('source', 'type')).to eq('web_chat')
+    expect(ticket.fetch('source')).not_to include('subject', 'body')
+    expect(DataImports::Freshdesk::MessageBatchBuilder.source_message_importable?(ticket.fetch('source'))).to be(false)
+    expect(parts.pluck('id')).to eq(%w[3101 3102 3103 3104 3105 3106])
+    expect(parts.map { |part| part.dig('author', 'type') }).to eq(%w[admin contact contact admin contact admin])
+    expect(parts.count { |part| part['body'].include?('FD-IMPORT-WEBCHAT-002') }).to eq(1)
+    expect(parts.last['attachments'].first).to include(
+      'name' => 'freshdesk-validation-diagnostic.txt',
+      'content_type' => 'text/plain',
+      'size' => 188
+    )
+  end
+end
diff --git a/spec/services/data_imports/freshdesk/source_bucket_spec.rb b/spec/services/data_imports/freshdesk/source_bucket_spec.rb
new file mode 100644
index 000000000..bb8a1e972
--- /dev/null
+++ b/spec/services/data_imports/freshdesk/source_bucket_spec.rb
@@ -0,0 +1,45 @@
+require 'rails_helper'
+
+RSpec.describe DataImports::Freshdesk::SourceBucket do
+  describe '.source_type' do
+    it 'maps documented and observed Freshdesk source identifiers', :aggregate_failures do
+      expect(described_class.source_type(1)).to eq('email')
+      expect(described_class.source_type(7)).to eq('chat')
+      expect(described_class.source_type(8)).to eq('mobihelp')
+      expect(described_class.source_type(11)).to eq('ecommerce')
+      expect(described_class.source_type(12)).to eq('bot')
+      expect(described_class.source_type(13)).to eq('whatsapp')
+      expect(described_class.source_type(14)).to eq('chat_internal_task')
+      expect(described_class.source_type(15)).to eq('web_chat')
+      expect(described_class.source_type(16)).to eq('web_form')
+      expect(described_class.source_type(17)).to eq('instagram_message')
+      expect(described_class.source_type(18)).to eq('instagram_comment')
+      expect(described_class.source_type(19)).to eq('facebook_message')
+      expect(described_class.source_type(20)).to eq('facebook_comment')
+      expect(described_class.source_type(21)).to eq('mobile_chat_sdk')
+      expect(described_class.source_type(22)).to eq('sms')
+    end
+
+    it 'uses unknown for an unsupported source identifier' do
+      expect(described_class.source_type(999)).to eq('unknown')
+    end
+  end
+
+  describe '.for' do
+    it 'groups equivalent sources and preserves distinct modern channels', :aggregate_failures do
+      expect(described_class.for('email')).to eq({ key: 'email', name: 'Email' })
+      expect(described_class.for('outbound_email')).to eq({ key: 'email', name: 'Email' })
+      expect(described_class.for('feedback_widget')).to eq({ key: 'portal', name: 'Portal' })
+      expect(described_class.for('whatsapp')).to eq({ key: 'whatsapp', name: 'WhatsApp' })
+      expect(described_class.for('chat_internal_task')).to eq({ key: 'internal_task', name: 'Internal task' })
+      expect(described_class.for('web_chat')).to eq({ key: 'chat', name: 'Chat' })
+      expect(described_class.for('web_form')).to eq({ key: 'portal', name: 'Portal' })
+      expect(described_class.for('instagram_message')).to eq({ key: 'instagram', name: 'Instagram' })
+      expect(described_class.for('instagram_comment')).to eq({ key: 'instagram', name: 'Instagram' })
+      expect(described_class.for('facebook_message')).to eq({ key: 'facebook', name: 'Facebook' })
+      expect(described_class.for('facebook_comment')).to eq({ key: 'facebook', name: 'Facebook' })
+      expect(described_class.for('mobile_chat_sdk')).to eq({ key: 'mobile', name: 'Mobile' })
+      expect(described_class.for('sms')).to eq({ key: 'sms', name: 'SMS' })
+    end
+  end
+end
diff --git a/spec/services/data_imports/freshdesk/source_spec.rb b/spec/services/data_imports/freshdesk/source_spec.rb
new file mode 100644
index 000000000..896c2d369
--- /dev/null
+++ b/spec/services/data_imports/freshdesk/source_spec.rb
@@ -0,0 +1,128 @@
+require 'rails_helper'
+
+RSpec.describe DataImports::Freshdesk::Source do
+  let(:client) { instance_double(DataImports::Freshdesk::Client) }
+  let(:ticket_fixture) do
+    JSON.parse(Rails.root.join('spec/fixtures/data_import/freshdesk/ticket_with_conversations.json').read)
+  end
+  let(:source) do
+    described_class.new(
+      access_token: 'freshdesk-api-key',
+      source_metadata: { domain: 'acme.freshdesk.com' }
+    )
+  end
+
+  before do
+    allow(DataImports::Freshdesk::Client).to receive(:new).with(
+      domain: 'acme.freshdesk.com',
+      api_key: 'freshdesk-api-key'
+    ).and_return(client)
+  end
+
+  describe '.source_metadata' do
+    it 'stores only a normalized Freshdesk domain' do
+      expect(described_class.source_metadata(domain: 'https://ACME.freshdesk.com/support/home')).to eq(
+        domain: 'acme.freshdesk.com'
+      )
+    end
+  end
+
+  describe '#list_contacts' do
+    it 'normalizes records and translates numeric pages into shared cursors' do
+      allow(client).to receive(:list_contacts).with(page: 2, per_page: 100).and_return(
+        DataImports::Freshdesk::Client::Page.new(
+          data: [{ 'id' => 1001, 'email' => 'customer@example.com' }],
+          next_page: 3
+        )
+      )
+
+      response = source.list_contacts(starting_after: 2, per_page: 100)
+
+      expect(response.dig('data', 0)).to include('id' => '1001', 'email' => 'customer@example.com')
+      expect(response.dig('pages', 'next', 'starting_after')).to eq(3)
+    end
+  end
+
+  describe '#list_conversations' do
+    it 'returns a resumable ticket chunk with a cursor after every ticket', :aggregate_failures do
+      tickets = Array.new(25) { |index| { 'id' => index + 1, 'source' => 1 } }
+      allow(client).to receive(:list_tickets).with(page: 2, per_page: 100).and_return(
+        DataImports::Freshdesk::Client::Page.new(data: tickets, next_page: 3)
+      )
+
+      response = source.list_conversations(
+        starting_after: { 'page' => 2, 'offset' => 10 },
+        per_page: 100
+      )
+
+      expect(response['data'].pluck('id')).to eq((11..20).map(&:to_s))
+      expect(response.dig('pages', 'checkpoints').first).to include('page' => 2, 'offset' => 11, 'next_page' => 3)
+      expect(response.dig('pages', 'checkpoints').last).to include('page' => 2, 'offset' => 20, 'next_page' => 3)
+      expect(response.dig('pages', 'next', 'starting_after')).to include('page' => 2, 'offset' => 20, 'next_page' => 3)
+    end
+
+    it 'reuses the cached ticket page before advancing to the next Freshdesk page', :aggregate_failures do
+      tickets = Array.new(25) { |index| { 'id' => index + 1, 'source' => 1 } }
+      expect(client).to receive(:list_tickets).with(page: 2, per_page: 100).once.and_return(
+        DataImports::Freshdesk::Client::Page.new(data: tickets, next_page: 3)
+      )
+
+      first_chunk = source.list_conversations(
+        starting_after: { 'page' => 2, 'offset' => 10 },
+        per_page: 100
+      )
+      response = source.list_conversations(starting_after: first_chunk.dig('pages', 'next', 'starting_after'), per_page: 100)
+
+      expect(response['data'].pluck('id')).to eq((21..25).map(&:to_s))
+      expect(response.dig('pages', 'checkpoints').last).to eq('page' => 3, 'offset' => 0)
+      expect(response.dig('pages', 'next', 'starting_after')).to eq('page' => 3, 'offset' => 0)
+    end
+
+    it 'reports the REST ticket limit only after the final chunk of a full page 300', :aggregate_failures do
+      tickets = Array.new(100) { |index| { 'id' => index + 1, 'source' => 1 } }
+      expect(client).to receive(:list_tickets).with(page: 300, per_page: 100).once.and_return(
+        DataImports::Freshdesk::Client::Page.new(data: tickets, next_page: nil)
+      )
+
+      first_chunk = source.list_conversations(starting_after: { 'page' => 300, 'offset' => 0 }, per_page: 100)
+      final_cursor = first_chunk.dig('pages', 'current', 'starting_after').merge('offset' => 90)
+      final_chunk = source.list_conversations(starting_after: final_cursor, per_page: 100)
+
+      expect(first_chunk.dig('pages', 'limit_reached')).to be(false)
+      expect(final_chunk['data'].pluck('id')).to eq((91..100).map(&:to_s))
+      expect(final_chunk.dig('pages', 'next')).to be_nil
+      expect(final_chunk.dig('pages', 'limit_reached')).to be(true)
+    end
+
+    it 'completes a partial page 300 without reporting the ticket limit' do
+      tickets = Array.new(99) { |index| { 'id' => index + 1, 'source' => 1 } }
+      allow(client).to receive(:list_tickets).with(page: 300, per_page: 100).and_return(
+        DataImports::Freshdesk::Client::Page.new(data: tickets, next_page: nil)
+      )
+
+      response = source.list_conversations(starting_after: { 'page' => 300, 'offset' => 90 }, per_page: 100)
+
+      expect(response.dig('pages', 'next')).to be_nil
+      expect(response.dig('pages', 'limit_reached')).to be(false)
+    end
+  end
+
+  describe '#retrieve_conversation' do
+    it 'retrieves every conversation page and normalizes the ticket', :aggregate_failures do
+      conversations = ticket_fixture.fetch('conversations')
+      allow(client).to receive(:retrieve_ticket).with('2001').and_return(ticket_fixture.fetch('ticket'))
+      allow(client).to receive(:list_conversations).with('2001', page: 1, per_page: 100).and_return(
+        DataImports::Freshdesk::Client::Page.new(data: conversations.first(2), next_page: 2)
+      )
+      allow(client).to receive(:list_conversations).with('2001', page: 2, per_page: 100).and_return(
+        DataImports::Freshdesk::Client::Page.new(data: conversations.last(1), next_page: nil)
+      )
+
+      ticket = source.retrieve_conversation('2001')
+
+      expect(ticket['id']).to eq('2001')
+      expect(ticket.dig('conversation_parts', 'total_count')).to eq(3)
+      expect(ticket.dig('conversation_parts', 'conversation_parts').pluck('id')).to eq(%w[3001 3002 3003])
+    end
+  end
+end
diff --git a/spec/services/data_imports/intercom/placeholder_inbox_builder_spec.rb b/spec/services/data_imports/intercom/placeholder_inbox_builder_spec.rb
index c1a7baab5..ed4406676 100644
--- a/spec/services/data_imports/intercom/placeholder_inbox_builder_spec.rb
+++ b/spec/services/data_imports/intercom/placeholder_inbox_builder_spec.rb
@@ -29,5 +29,27 @@ RSpec.describe DataImports::Intercom::PlaceholderInboxBuilder do
       expect(second_inbox).to eq(first_inbox)
       expect(Inbox.where(account: account, channel_type: 'Channel::Api').count).to eq(1)
     end
+
+    it 'creates editable default working hours without running inbox creation callbacks' do
+      inbox = described_class.new(account: account).inbox_for('email')
+
+      expect(inbox.working_hours.count).to eq(7)
+
+      inbox.update_working_hours(
+        [
+          {
+            'day_of_week' => 1,
+            'open_hour' => 10,
+            'open_minutes' => 0,
+            'close_hour' => 18,
+            'close_minutes' => 0,
+            'closed_all_day' => false,
+            'open_all_day' => false
+          }
+        ]
+      )
+
+      expect(inbox.working_hours.find_by(day_of_week: 1)).to have_attributes(open_hour: 10, close_hour: 18)
+    end
   end
 end
diff --git a/spec/services/data_imports/source_spec.rb b/spec/services/data_imports/source_spec.rb
new file mode 100644
index 000000000..57582b654
--- /dev/null
+++ b/spec/services/data_imports/source_spec.rb
@@ -0,0 +1,26 @@
+require 'rails_helper'
+
+RSpec.describe DataImports::Source do
+  describe '.source_class' do
+    it 'resolves each supported integration adapter', :aggregate_failures do
+      expect(described_class.source_class('intercom')).to eq(DataImports::Intercom::Source)
+      expect(described_class.source_class('freshdesk')).to eq(DataImports::Freshdesk::Source)
+      expect(described_class.supported?('intercom')).to be(true)
+      expect(described_class.supported?('freshdesk')).to be(true)
+    end
+
+    it 'rejects unsupported providers' do
+      expect { described_class.source_class('zendesk') }.to raise_error(ArgumentError, 'Unsupported import source.')
+    end
+  end
+
+  describe '.for' do
+    it 'builds the configured adapter from persisted credentials' do
+      data_import = build(:data_import, :freshdesk)
+
+      source = described_class.for(data_import)
+
+      expect(source).to have_attributes(provider: 'freshdesk', display_name: 'Freshdesk')
+    end
+  end
+end