diff --git a/UPDATING.md b/UPDATING.md
index 2327fcfa3fdb4..a23aec5907731 100644
--- a/UPDATING.md
+++ b/UPDATING.md
@@ -51,6 +51,7 @@ assists people when migrating to a new version.
   translations inside the python package. This includes the .mo files needed by pybabel on the
   backend, as well as the .json files used by the frontend. If you were doing anything before
   as part of your bundling to expose translation packages, it's probably not needed anymore.
+- [29264](https://github.com/apache/superset/pull/29264) Slack has updated its file upload api, and we are now supporting this new api in Superset, although the Slack api is not backward compatible. The original Slack integration is deprecated and we will require a new Slack scope `channels:read` to be added to Slack workspaces in order to use this new api. In an upcoming release, we will make this new Slack scope mandatory and remove the old Slack functionality.
 
 ### Potential Downtime
 
diff --git a/superset-frontend/packages/superset-ui-core/src/utils/featureFlags.ts b/superset-frontend/packages/superset-ui-core/src/utils/featureFlags.ts
index b3af431d52bba..8ffc4f845d97b 100644
--- a/superset-frontend/packages/superset-ui-core/src/utils/featureFlags.ts
+++ b/superset-frontend/packages/superset-ui-core/src/utils/featureFlags.ts
@@ -25,6 +25,7 @@ export enum FeatureFlag {
   AlertsAttachReports = 'ALERTS_ATTACH_REPORTS',
   AlertReports = 'ALERT_REPORTS',
   AlertReportTabs = 'ALERT_REPORT_TABS',
+  AlertReportSlackV2 = 'ALERT_REPORT_SLACK_V2',
   AllowFullCsvExport = 'ALLOW_FULL_CSV_EXPORT',
   AvoidColorsCollision = 'AVOID_COLORS_COLLISION',
   ChartPluginsExperimental = 'CHART_PLUGINS_EXPERIMENTAL',
diff --git a/superset-frontend/src/features/alerts/AlertReportModal.test.tsx b/superset-frontend/src/features/alerts/AlertReportModal.test.tsx
index e32d13ab635f2..17047b7a404e4 100644
--- a/superset-frontend/src/features/alerts/AlertReportModal.test.tsx
+++ b/superset-frontend/src/features/alerts/AlertReportModal.test.tsx
@@ -30,7 +30,7 @@ jest.mock('@superset-ui/core', () => ({
 
 jest.mock('src/features/databases/state.ts', () => ({
   useCommonConf: () => ({
-    ALERT_REPORTS_NOTIFICATION_METHODS: ['Email', 'Slack'],
+    ALERT_REPORTS_NOTIFICATION_METHODS: ['Email', 'Slack', 'SlackV2'],
   }),
 }));
 
diff --git a/superset-frontend/src/features/alerts/AlertReportModal.tsx b/superset-frontend/src/features/alerts/AlertReportModal.tsx
index 633138e5796c2..78f2a8d4db53d 100644
--- a/superset-frontend/src/features/alerts/AlertReportModal.tsx
+++ b/superset-frontend/src/features/alerts/AlertReportModal.tsx
@@ -517,7 +517,7 @@ const AlertReportModal: FunctionComponent<AlertReportModalProps> = ({
     ]);
 
     setNotificationAddState(
-      notificationSettings.length === allowedNotificationMethods.length
+      notificationSettings.length === allowedNotificationMethodsCount
         ? 'hidden'
         : 'disabled',
     );
@@ -1235,6 +1235,20 @@ const AlertReportModal: FunctionComponent<AlertReportModalProps> = ({
     enforceValidation();
   }, [validationStatus]);
 
+  const allowedNotificationMethodsCount = useMemo(
+    () =>
+      allowedNotificationMethods.reduce((accum: string[], setting: string) => {
+        if (
+          accum.some(nm => nm.includes('slack')) &&
+          setting.toLowerCase().includes('slack')
+        ) {
+          return accum;
+        }
+        return [...accum, setting.toLowerCase()];
+      }, []).length,
+    [allowedNotificationMethods],
+  );
+
   // Show/hide
   if (isHidden && show) {
     setIsHidden(false);
@@ -1743,7 +1757,7 @@ const AlertReportModal: FunctionComponent<AlertReportModalProps> = ({
           ))}
           {
             // Prohibit 'add notification method' button if only one present
-            allowedNotificationMethods.length > notificationSettings.length && (
+            allowedNotificationMethodsCount > notificationSettings.length && (
               <NotificationMethodAdd
                 data-test="notification-add"
                 status={notificationAddState}
diff --git a/superset-frontend/src/features/alerts/components/NotificationMethod.test.tsx b/superset-frontend/src/features/alerts/components/NotificationMethod.test.tsx
new file mode 100644
index 0000000000000..f4f4b34f29c25
--- /dev/null
+++ b/superset-frontend/src/features/alerts/components/NotificationMethod.test.tsx
@@ -0,0 +1,177 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { render, screen, fireEvent } from 'spec/helpers/testing-library';
+import { NotificationMethod } from './NotificationMethod';
+import { NotificationSetting } from '../types';
+
+const mockOnUpdate = jest.fn();
+const mockOnRemove = jest.fn();
+const mockOnInputChange = jest.fn();
+const mockSetErrorSubject = jest.fn();
+
+const mockSetting: NotificationSetting = {
+  method: 'Email',
+  recipients: 'test@example.com',
+  options: ['Email', 'Slack', 'SlackV2'],
+};
+
+const mockEmailSubject = 'Test Subject';
+const mockDefaultSubject = 'Default Subject';
+
+describe('NotificationMethod', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should render the component', () => {
+    render(
+      <NotificationMethod
+        setting={mockSetting}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+        onInputChange={mockOnInputChange}
+        email_subject={mockEmailSubject}
+        defaultSubject={mockDefaultSubject}
+        setErrorSubject={mockSetErrorSubject}
+      />,
+    );
+
+    expect(screen.getByText('Notification Method')).toBeInTheDocument();
+    expect(
+      screen.getByText('Email subject name (optional)'),
+    ).toBeInTheDocument();
+    expect(screen.getByText('Email recipients')).toBeInTheDocument();
+  });
+
+  it('should call onUpdate when the method is changed', () => {
+    render(
+      <NotificationMethod
+        setting={mockSetting}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+        onInputChange={mockOnInputChange}
+        email_subject={mockEmailSubject}
+        defaultSubject={mockDefaultSubject}
+        setErrorSubject={mockSetErrorSubject}
+      />,
+    );
+
+    const select = screen.getByLabelText('Delivery method');
+    fireEvent.change(select, { target: { value: 'Slack' } });
+
+    expect(mockOnUpdate).toHaveBeenCalledWith(0, {
+      ...mockSetting,
+      method: 'Slack',
+      recipients: '',
+    });
+  });
+
+  it('should call onRemove when the delete button is clicked', () => {
+    render(
+      <NotificationMethod
+        setting={mockSetting}
+        index={1}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+        onInputChange={mockOnInputChange}
+        email_subject={mockEmailSubject}
+        defaultSubject={mockDefaultSubject}
+        setErrorSubject={mockSetErrorSubject}
+      />,
+    );
+
+    const deleteButton = screen.getByRole('button');
+    fireEvent.click(deleteButton);
+
+    expect(mockOnRemove).toHaveBeenCalledWith(1);
+  });
+
+  it('should call onRecipientsChange when the recipients value is changed', () => {
+    render(
+      <NotificationMethod
+        setting={mockSetting}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+        onInputChange={mockOnInputChange}
+        email_subject={mockEmailSubject}
+        defaultSubject={mockDefaultSubject}
+        setErrorSubject={mockSetErrorSubject}
+      />,
+    );
+
+    const recipientsInput = screen.getByTestId('recipients');
+    fireEvent.change(recipientsInput, {
+      target: { value: 'test1@example.com' },
+    });
+
+    expect(mockOnUpdate).toHaveBeenCalledWith(0, {
+      ...mockSetting,
+      recipients: 'test1@example.com',
+    });
+  });
+
+  it('should call onSlackRecipientsChange when the slack recipients value is changed', () => {
+    render(
+      <NotificationMethod
+        setting={{ ...mockSetting, method: 'Slack' }}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+        onInputChange={mockOnInputChange}
+        email_subject={mockEmailSubject}
+        defaultSubject={mockDefaultSubject}
+        setErrorSubject={mockSetErrorSubject}
+      />,
+    );
+
+    const slackRecipientsInput = screen.getByLabelText('Select owners');
+    fireEvent.change(slackRecipientsInput, [
+      { label: 'User 1', value: 'user1' },
+      { label: 'User 2', value: 'user2' },
+    ]);
+
+    expect(mockOnUpdate).toHaveBeenCalledWith(0, {
+      ...mockSetting,
+      recipients: 'user1,user2',
+    });
+  });
+
+  it('should call onSubjectChange when the email subject value is changed', () => {
+    render(
+      <NotificationMethod
+        setting={mockSetting}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+        onInputChange={mockOnInputChange}
+        email_subject={mockEmailSubject}
+        defaultSubject={mockDefaultSubject}
+        setErrorSubject={mockSetErrorSubject}
+      />,
+    );
+
+    const subjectInput = screen.getByPlaceholderText('Default Subject');
+    fireEvent.change(subjectInput, { target: { value: 'Test Subject' } });
+
+    expect(mockOnInputChange).toHaveBeenCalled();
+  });
+});
diff --git a/superset-frontend/src/features/alerts/components/NotificationMethod.tsx b/superset-frontend/src/features/alerts/components/NotificationMethod.tsx
index b2d780423bc13..c38d649c7828d 100644
--- a/superset-frontend/src/features/alerts/components/NotificationMethod.tsx
+++ b/superset-frontend/src/features/alerts/components/NotificationMethod.tsx
@@ -16,10 +16,24 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { FunctionComponent, useState, ChangeEvent } from 'react';
+import {
+  FunctionComponent,
+  useState,
+  ChangeEvent,
+  useEffect,
+  useMemo,
+} from 'react';
 
-import { styled, t, useTheme } from '@superset-ui/core';
-import { Select } from 'src/components';
+import {
+  FeatureFlag,
+  SupersetClient,
+  isFeatureEnabled,
+  styled,
+  t,
+  useTheme,
+} from '@superset-ui/core';
+import rison from 'rison';
+import { AsyncSelect, Select } from 'src/components';
 import Icons from 'src/components/Icons';
 import { NotificationMethodOption, NotificationSetting } from '../types';
 import { StyledInputContainer } from '../AlertReportModal';
@@ -87,20 +101,57 @@ export const NotificationMethod: FunctionComponent<NotificationMethodProps> = ({
   const [recipientValue, setRecipientValue] = useState<string>(
     recipients || '',
   );
+  const [slackRecipients, setSlackRecipients] = useState<
+    { label: string; value: string }[]
+  >([]);
   const [error, setError] = useState(false);
   const theme = useTheme();
 
-  if (!setting) {
-    return null;
-  }
+  const [useSlackV1, setUseSlackV1] = useState<boolean>(false);
+
+  const mapChannelsToOptions = (result: { name: any; id: any }[]) =>
+    result.map((result: { name: any; id: any }) => ({
+      label: result.name,
+      value: result.id,
+    }));
 
-  const onMethodChange = (method: NotificationMethodOption) => {
+  const loadChannels = async (
+    search_string: string | undefined = '',
+  ): Promise<{
+    data: { label: any; value: any }[];
+    totalCount: number;
+  }> => {
+    const query = rison.encode({ search_string });
+    const endpoint = `/api/v1/report/slack_channels/?q=${query}`;
+    const noResults = { data: [], totalCount: 0 };
+    return SupersetClient.get({ endpoint })
+      .then(({ json }) => {
+        const { result, count } = json;
+
+        const options: { label: any; value: any }[] =
+          mapChannelsToOptions(result);
+
+        return {
+          data: options,
+          totalCount: (count ?? options.length) as number,
+        };
+      })
+      .catch(() => {
+        // Fallback to slack v1 if slack v2 is not compatible
+        setUseSlackV1(true);
+        return noResults;
+      });
+  };
+  const onMethodChange = (selected: {
+    label: string;
+    value: NotificationMethodOption;
+  }) => {
     // Since we're swapping the method, reset the recipients
     setRecipientValue('');
-    if (onUpdate) {
+    if (onUpdate && setting) {
       const updatedSetting = {
         ...setting,
-        method,
+        method: selected.value,
         recipients: '',
       };
 
@@ -108,6 +159,42 @@ export const NotificationMethod: FunctionComponent<NotificationMethodProps> = ({
     }
   };
 
+  useEffect(() => {
+    // fetch slack channel names from
+    // ids on first load
+    if (method && ['Slack', 'SlackV2'].includes(method)) {
+      loadChannels(recipients).then(response => {
+        setSlackRecipients(response.data || []);
+        // if fetch succeeds, set the method to SlackV2
+        onMethodChange({ label: 'Slack', value: 'SlackV2' });
+      });
+    }
+  }, []);
+
+  const formattedOptions = useMemo(
+    () =>
+      (options || [])
+        .filter(
+          method =>
+            (isFeatureEnabled(FeatureFlag.AlertReportSlackV2) &&
+              !useSlackV1 &&
+              method === 'SlackV2') ||
+            ((!isFeatureEnabled(FeatureFlag.AlertReportSlackV2) ||
+              useSlackV1) &&
+              method === 'Slack') ||
+            method === 'Email',
+        )
+        .map(method => ({
+          label: method === 'SlackV2' ? 'Slack' : method,
+          value: method,
+        })),
+    [options],
+  );
+
+  if (!setting) {
+    return null;
+  }
+
   const onRecipientsChange = (event: ChangeEvent<HTMLTextAreaElement>) => {
     const { target } = event;
 
@@ -123,6 +210,21 @@ export const NotificationMethod: FunctionComponent<NotificationMethodProps> = ({
     }
   };
 
+  const onSlackRecipientsChange = (
+    recipients: { label: string; value: string }[],
+  ) => {
+    setSlackRecipients(recipients);
+
+    if (onUpdate) {
+      const updatedSetting = {
+        ...setting,
+        recipients: recipients?.map(obj => obj.value).join(','),
+      };
+
+      onUpdate(index, updatedSetting);
+    }
+  };
+
   const onSubjectChange = (
     event: ChangeEvent<HTMLTextAreaElement | HTMLInputElement>,
   ) => {
@@ -153,15 +255,12 @@ export const NotificationMethod: FunctionComponent<NotificationMethodProps> = ({
             <Select
               ariaLabel={t('Delivery method')}
               data-test="select-delivery-method"
+              labelInValue
               onChange={onMethodChange}
               placeholder={t('Select Delivery Method')}
-              options={(options || []).map(
-                (method: NotificationMethodOption) => ({
-                  label: method,
-                  value: method,
-                }),
-              )}
-              value={method}
+              options={formattedOptions}
+              showSearch
+              value={formattedOptions.find(option => option.value === method)}
             />
             {index !== 0 && !!onRemove ? (
               <span
@@ -211,19 +310,37 @@ export const NotificationMethod: FunctionComponent<NotificationMethodProps> = ({
           <div className="inline-container">
             <StyledInputContainer>
               <div className="control-label">
-                {t('%s recipients', method)}
+                {t('%s recipients', method === 'SlackV2' ? 'Slack' : method)}
                 <span className="required">*</span>
               </div>
-              <div className="input-container">
-                <textarea
-                  name="recipients"
-                  data-test="recipients"
-                  value={recipientValue}
-                  onChange={onRecipientsChange}
-                />
-              </div>
-              <div className="helper">
-                {t('Recipients are separated by "," or ";"')}
+              <div>
+                {['Email', 'Slack'].includes(method) ? (
+                  <>
+                    <div className="input-container">
+                      <textarea
+                        name="recipients"
+                        data-test="recipients"
+                        value={recipientValue}
+                        onChange={onRecipientsChange}
+                      />
+                    </div>
+                    <div className="helper">
+                      {t('Recipients are separated by "," or ";"')}
+                    </div>
+                  </>
+                ) : (
+                  // for SlackV2
+                  <AsyncSelect
+                    ariaLabel={t('Select channels')}
+                    mode="multiple"
+                    name="recipients"
+                    value={slackRecipients}
+                    options={loadChannels}
+                    onChange={onSlackRecipientsChange}
+                    allowClear
+                    data-test="recipients"
+                  />
+                )}
               </div>
             </StyledInputContainer>
           </div>
diff --git a/superset-frontend/src/features/alerts/components/RecipientIcon.tsx b/superset-frontend/src/features/alerts/components/RecipientIcon.tsx
index c1c1127cb9398..bcaedf658d261 100644
--- a/superset-frontend/src/features/alerts/components/RecipientIcon.tsx
+++ b/superset-frontend/src/features/alerts/components/RecipientIcon.tsx
@@ -41,6 +41,10 @@ export default function RecipientIcon({ type }: { type: string }) {
       recipientIconConfig.icon = <Icons.Slack css={StyledIcon} />;
       recipientIconConfig.label = RecipientIconName.Slack;
       break;
+    case RecipientIconName.SlackV2:
+      recipientIconConfig.icon = <Icons.Slack css={StyledIcon} />;
+      recipientIconConfig.label = RecipientIconName.Slack;
+      break;
     default:
       recipientIconConfig.icon = null;
       recipientIconConfig.label = '';
diff --git a/superset-frontend/src/features/alerts/types.ts b/superset-frontend/src/features/alerts/types.ts
index 932a744663d8f..8faf7c4af6fae 100644
--- a/superset-frontend/src/features/alerts/types.ts
+++ b/superset-frontend/src/features/alerts/types.ts
@@ -41,7 +41,7 @@ export type DatabaseObject = {
   id: number;
 };
 
-export type NotificationMethodOption = 'Email' | 'Slack';
+export type NotificationMethodOption = 'Email' | 'Slack' | 'SlackV2';
 
 export type NotificationSetting = {
   method?: NotificationMethodOption;
@@ -124,6 +124,7 @@ export enum AlertState {
 export enum RecipientIconName {
   Email = 'Email',
   Slack = 'Slack',
+  SlackV2 = 'SlackV2',
 }
 export interface AlertsReportsConfig {
   ALERT_REPORTS_DEFAULT_WORKING_TIMEOUT: number;
diff --git a/superset/commands/report/execute.py b/superset/commands/report/execute.py
index 1540fa70d8096..7468e1a7fab98 100644
--- a/superset/commands/report/execute.py
+++ b/superset/commands/report/execute.py
@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 import logging
+from copy import deepcopy
 from datetime import datetime, timedelta
 from typing import Any, Optional, Union
 from uuid import UUID
@@ -25,7 +26,7 @@
 from superset import app, db, security_manager
 from superset.commands.base import BaseCommand
 from superset.commands.dashboard.permalink.create import CreateDashboardPermalinkCommand
-from superset.commands.exceptions import CommandException
+from superset.commands.exceptions import CommandException, UpdateFailedError
 from superset.commands.report.alert import AlertCommand
 from superset.commands.report.exceptions import (
     ReportScheduleAlertGracePeriodError,
@@ -64,7 +65,10 @@
 )
 from superset.reports.notifications import create_notification
 from superset.reports.notifications.base import NotificationContent
-from superset.reports.notifications.exceptions import NotificationError
+from superset.reports.notifications.exceptions import (
+    NotificationError,
+    SlackV1NotificationError,
+)
 from superset.tasks.utils import get_executor
 from superset.utils import json
 from superset.utils.core import HeaderDataType, override_user
@@ -72,6 +76,7 @@
 from superset.utils.decorators import logs_context
 from superset.utils.pdf import build_pdf_from_screenshots
 from superset.utils.screenshots import ChartScreenshot, DashboardScreenshot
+from superset.utils.slack import get_channels_with_search
 from superset.utils.urls import get_url_path
 
 logger = logging.getLogger(__name__)
@@ -122,6 +127,30 @@ def update_report_schedule(self, state: ReportState) -> None:
         self._report_schedule.last_eval_dttm = datetime.utcnow()
         db.session.commit()
 
+    def update_report_schedule_slack_v2(self) -> None:
+        """
+        Update the report schedule type and channels for all slack recipients to v2.
+        V2 uses ids instead of names for channels.
+        """
+        try:
+            updated_recipients = []
+            for recipient in self._report_schedule.recipients:
+                recipient_copy = deepcopy(recipient)
+                if recipient_copy.type == ReportRecipientType.SLACK:
+                    recipient_copy.type = ReportRecipientType.SLACKV2
+                    slack_recipients = json.loads(recipient_copy.recipient_config_json)
+                    recipient_copy.recipient_config_json = json.dumps(
+                        {"target": get_channels_with_search(slack_recipients["target"])}
+                    )
+
+                updated_recipients.append(recipient_copy)
+            db.session.commit()
+        except Exception as ex:
+            logger.warning(
+                "Failed to update slack recipients to v2: %s", str(ex), exc_info=True
+            )
+            raise UpdateFailedError from ex
+
     def create_log(self, error_message: Optional[str] = None) -> None:
         """
         Creates a Report execution log, uses the current computed last_value for Alerts
@@ -440,6 +469,19 @@ def _send(
                     )
                 else:
                     notification.send()
+            except SlackV1NotificationError as ex:
+                # The slack notification should be sent with the v2 api
+                logger.info("Attempting to upgrade the report to Slackv2: %s", str(ex))
+                try:
+                    self.update_report_schedule_slack_v2()
+                    recipient.type = ReportRecipientType.SLACKV2
+                    notification = create_notification(recipient, notification_content)
+                    notification.send()
+                except UpdateFailedError as err:
+                    # log the error but keep processing the report with SlackV1
+                    logger.warning(
+                        "Failed to update slack recipients to v2: %s", str(err)
+                    )
             except (NotificationError, SupersetException) as ex:
                 # collect errors but keep processing them
                 notification_errors.append(
@@ -478,9 +520,10 @@ def send_error(self, name: str, message: str) -> None:
         """
         header_data = self._get_log_data()
         logger.info(
-            "header_data in notifications for alerts and reports %s, taskid, %s",
+            "header_data in notifications for alerts and reports %s, taskid, %s, recipients %s",
             header_data,
             self._execution_id,
+            json.loads(self._report_schedule.recipients.recipient_config_json),
         )
         notification_content = NotificationContent(
             name=name, text=message, header_data=header_data
diff --git a/superset/config.py b/superset/config.py
index cb77982994b37..1178a3026099f 100644
--- a/superset/config.py
+++ b/superset/config.py
@@ -444,6 +444,7 @@ class D3Format(TypedDict, total=False):
     # Enables Alerts and reports new implementation
     "ALERT_REPORTS": False,
     "ALERT_REPORT_TABS": False,
+    "ALERT_REPORTS_SLACK_V2": False,
     "DASHBOARD_RBAC": False,
     "ENABLE_ADVANCED_DATA_TYPES": False,
     # Enabling ALERTS_ATTACH_REPORTS, the system sends email and slack message
diff --git a/superset/constants.py b/superset/constants.py
index 42cde6115a1f4..6d181fb9cc012 100644
--- a/superset/constants.py
+++ b/superset/constants.py
@@ -171,6 +171,7 @@ class RouteMethod:  # pylint: disable=too-few-public-methods
     "excel_metadata": "excel_upload",
     "columnar_metadata": "columnar_upload",
     "csv_metadata": "csv_upload",
+    "slack_channels": "write",
 }
 
 EXTRA_FORM_DATA_APPEND_KEYS = {
diff --git a/superset/reports/api.py b/superset/reports/api.py
index 4a298b564dd8c..4cbe92e283d9a 100644
--- a/superset/reports/api.py
+++ b/superset/reports/api.py
@@ -40,15 +40,18 @@
 from superset.constants import MODEL_API_RW_METHOD_PERMISSION_MAP, RouteMethod
 from superset.dashboards.filters import DashboardAccessFilter
 from superset.databases.filters import DatabaseFilter
+from superset.exceptions import SupersetException
 from superset.extensions import event_logger
 from superset.reports.filters import ReportScheduleAllTextFilter, ReportScheduleFilter
 from superset.reports.models import ReportSchedule
 from superset.reports.schemas import (
     get_delete_ids_schema,
+    get_slack_channels_schema,
     openapi_spec_methods_override,
     ReportSchedulePostSchema,
     ReportSchedulePutSchema,
 )
+from superset.utils.slack import get_channels_with_search
 from superset.views.base_api import (
     BaseSupersetModelRestApi,
     RelatedFieldFilter,
@@ -71,7 +74,8 @@ def ensure_alert_reports_enabled(self) -> Optional[Response]:
 
     include_route_methods = RouteMethod.REST_MODEL_VIEW_CRUD_SET | {
         RouteMethod.RELATED,
-        "bulk_delete",  # not using RouteMethod since locally defined
+        "bulk_delete",
+        "slack_channels",  # not using RouteMethod since locally defined
     }
     class_permission_name = "ReportSchedule"
     method_permission_name = MODEL_API_RW_METHOD_PERMISSION_MAP
@@ -513,3 +517,63 @@ def bulk_delete(self, **kwargs: Any) -> Response:
             return self.response_403()
         except ReportScheduleDeleteFailedError as ex:
             return self.response_422(message=str(ex))
+
+    @expose("/slack_channels/", methods=("GET",))
+    @protect()
+    @rison(get_slack_channels_schema)
+    @safe
+    @statsd_metrics
+    @event_logger.log_this_with_context(
+        action=lambda self,
+        *args,
+        **kwargs: f"{self.__class__.__name__}.slack_channels",
+        log_to_statsd=False,
+    )
+    def slack_channels(self, **kwargs: Any) -> Response:
+        """Get slack channels.
+        ---
+        get:
+          summary: Get slack channels
+          description: Get slack channels
+          parameters:
+            - in: query
+              name: q
+              content:
+                application/json:
+                  schema:
+                    $ref: '#/components/schemas/get_slack_channels_schema'
+          responses:
+            200:
+              description: Slack channels
+              content:
+                application/json:
+                  schema:
+                    type: object
+                    properties:
+                      result:
+                        type: array
+                        items:
+                          type: object
+                          properties:
+                            id:
+                              type: string
+                            name:
+                              type: string
+            401:
+              $ref: '#/components/responses/401'
+            403:
+              $ref: '#/components/responses/403'
+            404:
+              $ref: '#/components/responses/404'
+            422:
+              $ref: '#/components/responses/422'
+            500:
+              $ref: '#/components/responses/500'
+        """
+        try:
+            search_string = kwargs.get("rison", {}).get("search_string")
+            channels = get_channels_with_search(search_string=search_string)
+            return self.response(200, result=channels)
+        except SupersetException as ex:
+            logger.error("Error fetching slack channels %s", str(ex))
+            return self.response_422(message=str(ex))
diff --git a/superset/reports/models.py b/superset/reports/models.py
index 3627a2ebf46ea..e4cdd7c9b4d0e 100644
--- a/superset/reports/models.py
+++ b/superset/reports/models.py
@@ -62,6 +62,7 @@ class ReportScheduleValidatorType(StrEnum):
 class ReportRecipientType(StrEnum):
     EMAIL = "Email"
     SLACK = "Slack"
+    SLACKV2 = "SlackV2"
 
 
 class ReportState(StrEnum):
diff --git a/superset/reports/notifications/__init__.py b/superset/reports/notifications/__init__.py
index 770ce43e2142c..938e3934475c9 100644
--- a/superset/reports/notifications/__init__.py
+++ b/superset/reports/notifications/__init__.py
@@ -18,6 +18,7 @@
 from superset.reports.notifications.base import BaseNotification, NotificationContent
 from superset.reports.notifications.email import EmailNotification  # noqa: F401
 from superset.reports.notifications.slack import SlackNotification  # noqa: F401
+from superset.reports.notifications.slackv2 import SlackV2Notification  # noqa: F401
 
 
 def create_notification(
diff --git a/superset/reports/notifications/exceptions.py b/superset/reports/notifications/exceptions.py
index aa06906f826b7..9cf87ed71e34f 100644
--- a/superset/reports/notifications/exceptions.py
+++ b/superset/reports/notifications/exceptions.py
@@ -24,6 +24,14 @@ class NotificationError(SupersetException):
     """
 
 
+class SlackV1NotificationError(SupersetException):
+    """
+    Report should not be run with the slack v1 api
+    """
+
+    status = 422
+
+
 class NotificationParamException(SupersetException):
     status = 422
 
diff --git a/superset/reports/notifications/slack.py b/superset/reports/notifications/slack.py
index 6a6bbda7bac7d..86bb6ef4e67a9 100644
--- a/superset/reports/notifications/slack.py
+++ b/superset/reports/notifications/slack.py
@@ -17,13 +17,10 @@
 import logging
 from collections.abc import Sequence
 from io import IOBase
-from typing import List, Union
+from typing import Union
 
 import backoff
-import pandas as pd
-from deprecation import deprecated
 from flask import g
-from flask_babel import gettext as __
 from slack_sdk import WebClient
 from slack_sdk.errors import (
     BotUserAccessError,
@@ -43,26 +40,30 @@
     NotificationMalformedException,
     NotificationParamException,
     NotificationUnprocessableException,
+    SlackV1NotificationError,
 )
+from superset.reports.notifications.slack_mixin import SlackMixin
 from superset.utils import json
 from superset.utils.core import get_email_address_list
 from superset.utils.decorators import statsd_gauge
-from superset.utils.slack import get_slack_client
+from superset.utils.slack import (
+    get_slack_client,
+    should_use_v2_api,
+)
+from superset.views.base import deprecated
 
 logger = logging.getLogger(__name__)
 
-# Slack only allows Markdown messages up to 4k chars
-MAXIMUM_MESSAGE_SIZE = 4000
-
 
-class SlackNotification(BaseNotification):  # pylint: disable=too-few-public-methods
+@deprecated(eol_version="6.0.0")
+class SlackNotification(SlackMixin, BaseNotification):  # pylint: disable=too-few-public-methods
     """
     Sends a slack notification for a report recipient
     """
 
     type = ReportRecipientType.SLACK
 
-    def _get_channels(self, client: WebClient) -> List[str]:
+    def _get_channels(self, client: WebClient) -> list[str]:
         """
         Get the recipient's channel(s).
         :returns: A list of channel ids: "EID676L"
@@ -70,7 +71,7 @@ def _get_channels(self, client: WebClient) -> List[str]:
         """
         recipient_str = json.loads(self._recipient.recipient_config_json)["target"]
 
-        channel_recipients: List[str] = get_email_address_list(recipient_str)
+        channel_recipients: list[str] = get_email_address_list(recipient_str)
 
         conversations_list_response = client.conversations_list(
             types="public_channel,private_channel"
@@ -82,133 +83,39 @@ def _get_channels(self, client: WebClient) -> List[str]:
             if c["name"] in channel_recipients
         ]
 
-    def _message_template(self, table: str = "") -> str:
-        return __(
-            """*%(name)s*
-
-%(description)s
-
-<%(url)s|Explore in Superset>
-
-%(table)s
-""",
-            name=self._content.name,
-            description=self._content.description or "",
-            url=self._content.url,
-            table=table,
-        )
-
-    @staticmethod
-    def _error_template(name: str, description: str, text: str) -> str:
-        return __(
-            """*%(name)s*
-
-%(description)s
-
-Error: %(text)s
-""",
-            name=name,
-            description=description,
-            text=text,
-        )
-
-    def _get_body(self) -> str:
-        if self._content.text:
-            return self._error_template(
-                self._content.name, self._content.description or "", self._content.text
-            )
-
-        if self._content.embedded_data is None:
-            return self._message_template()
-
-        # Embed data in the message
-        df = self._content.embedded_data
-
-        # Flatten columns/index so they show up nicely in the table
-        df.columns = [
-            (
-                " ".join(str(name) for name in column).strip()
-                if isinstance(column, tuple)
-                else column
-            )
-            for column in df.columns
-        ]
-        df.index = [
-            (
-                " ".join(str(name) for name in index).strip()
-                if isinstance(index, tuple)
-                else index
-            )
-            for index in df.index
-        ]
-
-        # Slack Markdown only works on messages shorter than 4k chars, so we might
-        # need to truncate the data
-        for i in range(len(df) - 1):
-            truncated_df = df[: i + 1].fillna("")
-            truncated_row = pd.Series({k: "..." for k in df.columns})
-            truncated_df = pd.concat(
-                [truncated_df, truncated_row.to_frame().T], ignore_index=True
-            )
-            tabulated = df.to_markdown()
-            table = f"```\n{tabulated}\n```\n\n(table was truncated)"
-            message = self._message_template(table)
-            if len(message) > MAXIMUM_MESSAGE_SIZE:
-                # Decrement i and build a message that is under the limit
-                truncated_df = df[:i].fillna("")
-                truncated_row = pd.Series({k: "..." for k in df.columns})
-                truncated_df = pd.concat(
-                    [truncated_df, truncated_row.to_frame().T], ignore_index=True
-                )
-                tabulated = df.to_markdown()
-                table = (
-                    f"```\n{tabulated}\n```\n\n(table was truncated)"
-                    if len(truncated_df) > 0
-                    else ""
-                )
-                break
-
-        # Send full data
-        else:
-            tabulated = df.to_markdown()
-            table = f"```\n{tabulated}\n```"
-
-        return self._message_template(table)
-
     def _get_inline_files(
         self,
-    ) -> Sequence[Union[str, IOBase, bytes]]:
-        if self._content.csv:
-            return [self._content.csv]
-        if self._content.screenshots:
-            return self._content.screenshots
-        if self._content.pdf:
-            return [self._content.pdf]
-        return []
-
-    @deprecated(deprecated_in="4.1")
-    def _deprecated_upload_files(
-        self, client: WebClient, title: str, body: str
-    ) -> None:
-        """
-        Deprecated method to upload files to slack
-        Should only be used if the new method fails
-        To be removed in the next major release
-        """
-        file_type, files = (None, [])
+    ) -> tuple[Union[str, None], Sequence[Union[str, IOBase, bytes]]]:
         if self._content.csv:
-            file_type, files = ("csv", [self._content.csv])
+            return ("csv", [self._content.csv])
         if self._content.screenshots:
-            file_type, files = ("png", self._content.screenshots)
+            return ("png", self._content.screenshots)
         if self._content.pdf:
-            file_type, files = ("pdf", [self._content.pdf])
+            return ("pdf", [self._content.pdf])
+        return (None, [])
 
-        recipient_str = json.loads(self._recipient.recipient_config_json)["target"]
+    @backoff.on_exception(backoff.expo, SlackApiError, factor=10, base=2, max_tries=5)
+    @statsd_gauge("reports.slack.send")
+    def send(self) -> None:
+        file_type, files = self._get_inline_files()
+        title = self._content.name
+        body = self._get_body(content=self._content)
+        global_logs_context = getattr(g, "logs_context", {}) or {}
 
-        recipients = get_email_address_list(recipient_str)
+        # see if the v2 api will work
+        if should_use_v2_api():
+            # if we can fetch channels, then raise an error and use the v2 api
+            raise SlackV1NotificationError
 
-        for channel in recipients:
-            if len(files) > 0:
+        # use the v1 api but warn with a deprecation message
+        logger.warning(
+            "Your current Slack scopes are missing `channels:read`. Please add this to your Slack app in order to continue using the v1 API. Support for the old Slack API will be removed in Superset version 6.0.0."
+        )
+        try:
+            client = get_slack_client()
+            channel = self._get_channels(client=client)
+            # files_upload returns SlackResponse as we run it in sync mode.
+            if files:
                 for file in files:
                     client.files_upload(
                         channels=channel,
@@ -219,46 +126,6 @@ def _deprecated_upload_files(
                     )
             else:
                 client.chat_postMessage(channel=channel, text=body)
-
-    @backoff.on_exception(backoff.expo, SlackApiError, factor=10, base=2, max_tries=5)
-    @statsd_gauge("reports.slack.send")
-    def send(self) -> None:
-        global_logs_context = getattr(g, "logs_context", {}) or {}
-        try:
-            client = get_slack_client()
-            title = self._content.name
-            body = self._get_body()
-
-            try:
-                channels = self._get_channels(client)
-            except SlackApiError:
-                logger.warning(
-                    "Slack scope missing. Using deprecated API to get channels. Please update your Slack app to use the new API.",
-                    extra={
-                        "execution_id": global_logs_context.get("execution_id"),
-                    },
-                )
-                self._deprecated_upload_files(client, title, body)
-                return
-
-            if channels == []:
-                raise NotificationParamException("No valid channel found")
-
-            files = self._get_inline_files()
-
-            # files_upload returns SlackResponse as we run it in sync mode.
-            for channel in channels:
-                if len(files) > 0:
-                    for file in files:
-                        client.files_upload_v2(
-                            channel=channel,
-                            file=file,
-                            initial_comment=body,
-                            title=title,
-                        )
-                else:
-                    client.chat_postMessage(channel=channel, text=body)
-
             logger.info(
                 "Report sent to slack",
                 extra={
diff --git a/superset/reports/notifications/slack_mixin.py b/superset/reports/notifications/slack_mixin.py
new file mode 100644
index 0000000000000..4caf1b605e281
--- /dev/null
+++ b/superset/reports/notifications/slack_mixin.py
@@ -0,0 +1,124 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import pandas as pd
+from flask_babel import gettext as __
+
+from superset.reports.notifications.base import NotificationContent
+
+# Slack only allows Markdown messages up to 4k chars
+MAXIMUM_MESSAGE_SIZE = 4000
+
+
+# pylint: disable=too-few-public-methods
+class SlackMixin:
+    def _message_template(
+        self,
+        content: NotificationContent,
+        table: str = "",
+    ) -> str:
+        return __(
+            """*%(name)s*
+
+    %(description)s
+
+    <%(url)s|Explore in Superset>
+
+    %(table)s
+    """,
+            name=content.name,
+            description=content.description or "",
+            url=content.url,
+            table=table,
+        )
+
+    @staticmethod
+    def _error_template(name: str, description: str, text: str) -> str:
+        return __(
+            """*%(name)s*
+
+    %(description)s
+
+    Error: %(text)s
+    """,
+            name=name,
+            description=description,
+            text=text,
+        )
+
+    def _get_body(self, content: NotificationContent) -> str:
+        if content.text:
+            return self._error_template(
+                content.name, content.description or "", content.text
+            )
+
+        if content.embedded_data is None:
+            return self._message_template(content=content)
+
+        # Embed data in the message
+        df = content.embedded_data
+
+        # Flatten columns/index so they show up nicely in the table
+        df.columns = [
+            (
+                " ".join(str(name) for name in column).strip()
+                if isinstance(column, tuple)
+                else column
+            )
+            for column in df.columns
+        ]
+        df.index = [
+            (
+                " ".join(str(name) for name in index).strip()
+                if isinstance(index, tuple)
+                else index
+            )
+            for index in df.index
+        ]
+
+        # Slack Markdown only works on messages shorter than 4k chars, so we might
+        # need to truncate the data
+        for i in range(len(df) - 1):
+            truncated_df = df[: i + 1].fillna("")
+            truncated_row = pd.Series({k: "..." for k in df.columns})
+            truncated_df = pd.concat(
+                [truncated_df, truncated_row.to_frame().T], ignore_index=True
+            )
+            tabulated = df.to_markdown()
+            table = f"```\n{tabulated}\n```\n\n(table was truncated)"
+            message = self._message_template(table=table, content=content)
+            if len(message) > MAXIMUM_MESSAGE_SIZE:
+                # Decrement i and build a message that is under the limit
+                truncated_df = df[:i].fillna("")
+                truncated_row = pd.Series({k: "..." for k in df.columns})
+                truncated_df = pd.concat(
+                    [truncated_df, truncated_row.to_frame().T], ignore_index=True
+                )
+                tabulated = df.to_markdown()
+                table = (
+                    f"```\n{tabulated}\n```\n\n(table was truncated)"
+                    if len(truncated_df) > 0
+                    else ""
+                )
+                break
+
+        # Send full data
+        else:
+            tabulated = df.to_markdown()
+            table = f"```\n{tabulated}\n```"
+
+        return self._message_template(table=table, content=content)
diff --git a/superset/reports/notifications/slackv2.py b/superset/reports/notifications/slackv2.py
new file mode 100644
index 0000000000000..5b449474013f1
--- /dev/null
+++ b/superset/reports/notifications/slackv2.py
@@ -0,0 +1,131 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+import logging
+from collections.abc import Sequence
+from io import IOBase
+from typing import List, Union
+
+import backoff
+from flask import g
+from slack_sdk.errors import (
+    BotUserAccessError,
+    SlackApiError,
+    SlackClientConfigurationError,
+    SlackClientError,
+    SlackClientNotConnectedError,
+    SlackObjectFormationError,
+    SlackRequestError,
+    SlackTokenRotationError,
+)
+
+from superset.reports.models import ReportRecipientType
+from superset.reports.notifications.base import BaseNotification
+from superset.reports.notifications.exceptions import (
+    NotificationAuthorizationException,
+    NotificationMalformedException,
+    NotificationParamException,
+    NotificationUnprocessableException,
+)
+from superset.reports.notifications.slack_mixin import SlackMixin
+from superset.utils import json
+from superset.utils.core import get_email_address_list
+from superset.utils.decorators import statsd_gauge
+from superset.utils.slack import get_slack_client
+
+logger = logging.getLogger(__name__)
+
+
+class SlackV2Notification(SlackMixin, BaseNotification):  # pylint: disable=too-few-public-methods
+    """
+    Sends a slack notification for a report recipient with the slack upload v2 API
+    """
+
+    type = ReportRecipientType.SLACKV2
+
+    def _get_channels(self) -> List[str]:
+        """
+        Get the recipient's channel(s).
+        :returns: A list of channel ids: "EID676L"
+        :raises NotificationParamException or SlackApiError: If the recipient is not found
+        """
+        recipient_str = json.loads(self._recipient.recipient_config_json)["target"]
+
+        return get_email_address_list(recipient_str)
+
+    def _get_inline_files(
+        self,
+    ) -> Sequence[Union[str, IOBase, bytes]]:
+        if self._content.csv:
+            return [self._content.csv]
+        if self._content.screenshots:
+            return self._content.screenshots
+        if self._content.pdf:
+            return [self._content.pdf]
+        return []
+
+    @backoff.on_exception(backoff.expo, SlackApiError, factor=10, base=2, max_tries=5)
+    @statsd_gauge("reports.slack.send")
+    def send(self) -> None:
+        global_logs_context = getattr(g, "logs_context", {}) or {}
+        try:
+            client = get_slack_client()
+            title = self._content.name
+            body = self._get_body(content=self._content)
+
+            channels = self._get_channels()
+            logger.info("channels: %s", channels)
+
+            if not channels:
+                raise NotificationParamException("No recipients saved in the report")
+
+            files = self._get_inline_files()
+
+            # files_upload returns SlackResponse as we run it in sync mode.
+            for channel in channels:
+                if len(files) > 0:
+                    for file in files:
+                        client.files_upload_v2(
+                            channel=channel,
+                            file=file,
+                            initial_comment=body,
+                            title=title,
+                        )
+                else:
+                    client.chat_postMessage(channel=channel, text=body)
+
+            logger.info(
+                "Report sent to slack",
+                extra={
+                    "execution_id": global_logs_context.get("execution_id"),
+                },
+            )
+        except (
+            BotUserAccessError,
+            SlackRequestError,
+            SlackClientConfigurationError,
+        ) as ex:
+            raise NotificationParamException(str(ex)) from ex
+        except SlackObjectFormationError as ex:
+            raise NotificationMalformedException(str(ex)) from ex
+        except SlackTokenRotationError as ex:
+            raise NotificationAuthorizationException(str(ex)) from ex
+        except (SlackClientNotConnectedError, SlackApiError) as ex:
+            raise NotificationUnprocessableException(str(ex)) from ex
+        except SlackClientError as ex:
+            # this is the base class for all slack client errors
+            # keep it last so that it doesn't interfere with @backoff
+            raise NotificationUnprocessableException(str(ex)) from ex
diff --git a/superset/reports/schemas.py b/superset/reports/schemas.py
index f57a663e53de4..20cbff87b8efb 100644
--- a/superset/reports/schemas.py
+++ b/superset/reports/schemas.py
@@ -49,6 +49,12 @@
 }
 
 get_delete_ids_schema = {"type": "array", "items": {"type": "integer"}}
+get_slack_channels_schema = {
+    "type": "object",
+    "properties": {
+        "seach_string": {"type": "string"},
+    },
+}
 
 type_description = "The report schedule type"
 name_description = "The report schedule name."
diff --git a/superset/tasks/scheduler.py b/superset/tasks/scheduler.py
index cb55dc9f69ad8..df8c3c1c4f168 100644
--- a/superset/tasks/scheduler.py
+++ b/superset/tasks/scheduler.py
@@ -94,7 +94,7 @@ def execute(self: Celery.task, report_schedule_id: int) -> None:
         ).run()
     except ReportScheduleUnexpectedError:
         logger.exception(
-            "An unexpected occurred while executing the report: %s", task_id
+            "An unexpected error occurred while executing the report: %s", task_id
         )
         self.update_state(state="FAILURE")
     except CommandException as ex:
diff --git a/superset/utils/slack.py b/superset/utils/slack.py
index 8fa9013dfa547..0071883ce2a2a 100644
--- a/superset/utils/slack.py
+++ b/superset/utils/slack.py
@@ -16,8 +16,15 @@
 # under the License.
 
 
+import logging
+
 from flask import current_app
 from slack_sdk import WebClient
+from slack_sdk.errors import SlackApiError
+
+from superset.exceptions import SupersetException
+
+logger = logging.getLogger(__name__)
 
 
 class SlackClientError(Exception):
@@ -31,6 +38,53 @@ def get_slack_client() -> WebClient:
     return WebClient(token=token, proxy=current_app.config["SLACK_PROXY"])
 
 
+def get_channels_with_search(search_string: str = "", limit: int = 200) -> list[str]:
+    """
+    The slack api is paginated but does not include search, so we need to fetch
+    all channels and filter them ourselves
+    This will search by slack name or id
+    """
+
+    try:
+        client = get_slack_client()
+        channels = []
+        cursor = None
+
+        while True:
+            response = client.conversations_list(limit=limit, cursor=cursor)
+            channels.extend(response.data["channels"])
+            cursor = response.data.get("response_metadata", {}).get("next_cursor")
+            if not cursor:
+                break
+
+        # The search string can be multiple channels separated by commas
+        if search_string:
+            search_array = search_string.split(",")
+
+            channels = [
+                channel
+                for channel in channels
+                if any(
+                    search.lower() in channel["name"].lower()
+                    or search.lower() in channel["id"].lower()
+                    for search in search_array
+                )
+            ]
+        return channels
+    except (SlackClientError, SlackApiError) as ex:
+        raise SupersetException(f"Failed to list channels: {ex}") from ex
+
+
+def should_use_v2_api() -> bool:
+    try:
+        client = get_slack_client()
+        client.conversations_list()
+        logger.info("Slack API v2 is available")
+        return True
+    except SlackApiError:
+        return False
+
+
 def get_user_avatar(email: str, client: WebClient = None) -> str:
     client = client or get_slack_client()
     try:
diff --git a/superset/views/base.py b/superset/views/base.py
index be3af99147e81..8969a9759d474 100644
--- a/superset/views/base.py
+++ b/superset/views/base.py
@@ -402,6 +402,7 @@ def cached_common_bootstrap_data(  # pylint: disable=unused-argument
         frontend_config["ALERT_REPORTS_NOTIFICATION_METHODS"] = [
             ReportRecipientType.EMAIL,
             ReportRecipientType.SLACK,
+            ReportRecipientType.SLACKV2,
         ]
     else:
         frontend_config["ALERT_REPORTS_NOTIFICATION_METHODS"] = [