diff --git a/superset-frontend/packages/superset-ui-core/src/components/Icons/AntdEnhanced.tsx b/superset-frontend/packages/superset-ui-core/src/components/Icons/AntdEnhanced.tsx
index a079b54c16d..6f9222470c9 100644
--- a/superset-frontend/packages/superset-ui-core/src/components/Icons/AntdEnhanced.tsx
+++ b/superset-frontend/packages/superset-ui-core/src/components/Icons/AntdEnhanced.tsx
@@ -149,6 +149,7 @@ import {
   CompressOutlined,
   HistoryOutlined,
   SlackOutlined,
+  ApiOutlined,
 } from '@ant-design/icons';
 import { FC } from 'react';
 import { IconType } from './types';
@@ -287,6 +288,7 @@ const AntdIcons = {
   CompressOutlined,
   HistoryOutlined,
   SlackOutlined,
+  ApiOutlined,
 } as const;
 
 type AntdIconNames = keyof typeof AntdIcons;
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 fb3ec30d8c5..f5e38905ad5 100644
--- a/superset-frontend/packages/superset-ui-core/src/utils/featureFlags.ts
+++ b/superset-frontend/packages/superset-ui-core/src/utils/featureFlags.ts
@@ -26,6 +26,7 @@ export enum FeatureFlag {
   AlertReports = 'ALERT_REPORTS',
   AlertReportTabs = 'ALERT_REPORT_TABS',
   AlertReportSlackV2 = 'ALERT_REPORT_SLACK_V2',
+  AlertReportWebhook = 'ALERT_REPORT_WEBHOOK',
   AlertReportsFilter = 'ALERT_REPORTS_FILTER',
   AllowFullCsvExport = 'ALLOW_FULL_CSV_EXPORT',
   AvoidColorsCollision = 'AVOID_COLORS_COLLISION',
diff --git a/superset-frontend/src/features/alerts/AlertReportModal.tsx b/superset-frontend/src/features/alerts/AlertReportModal.tsx
index 8e2a356eab5..bb85bc12ff1 100644
--- a/superset-frontend/src/features/alerts/AlertReportModal.tsx
+++ b/superset-frontend/src/features/alerts/AlertReportModal.tsx
@@ -123,6 +123,7 @@ const EMAIL_REGEX = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
 
 const DEFAULT_NOTIFICATION_METHODS: NotificationMethodOption[] = [
   NotificationMethodOption.Email,
+  NotificationMethodOption.Webhook,
 ];
 const DEFAULT_NOTIFICATION_FORMAT = 'PNG';
 const DEFAULT_EXTRA_DASHBOARD_OPTIONS: Extra = {
diff --git a/superset-frontend/src/features/alerts/components/NotificationMethod.tsx b/superset-frontend/src/features/alerts/components/NotificationMethod.tsx
index 228130b32e5..f9c3c75f65d 100644
--- a/superset-frontend/src/features/alerts/components/NotificationMethod.tsx
+++ b/superset-frontend/src/features/alerts/components/NotificationMethod.tsx
@@ -338,6 +338,8 @@ export const NotificationMethod: FunctionComponent<NotificationMethodProps> = ({
             ((!isFeatureEnabled(FeatureFlag.AlertReportSlackV2) ||
               useSlackV1) &&
               method === NotificationMethodOption.Slack) ||
+            (isFeatureEnabled(FeatureFlag.AlertReportWebhook) &&
+              method === NotificationMethodOption.Webhook) ||
             method === NotificationMethodOption.Email,
         )
         .map(method => ({
@@ -354,7 +356,9 @@ export const NotificationMethod: FunctionComponent<NotificationMethodProps> = ({
     return null;
   }
 
-  const onRecipientsChange = (event: ChangeEvent<HTMLTextAreaElement>) => {
+  const onRecipientsChange = (
+    event: ChangeEvent<HTMLTextAreaElement | HTMLInputElement>,
+  ) => {
     const { target } = event;
 
     setRecipientValue(target.value);
@@ -476,9 +480,9 @@ export const NotificationMethod: FunctionComponent<NotificationMethodProps> = ({
       </div>
       {method !== undefined ? (
         <>
-          <div className="inline-container">
-            <StyledInputContainer>
-              {method === NotificationMethodOption.Email ? (
+          {method === NotificationMethodOption.Email ? (
+            <div className="inline-container">
+              <StyledInputContainer>
                 <>
                   <div className="control-label">
                     {TRANSLATIONS.EMAIL_SUBJECT_NAME}
@@ -503,66 +507,87 @@ export const NotificationMethod: FunctionComponent<NotificationMethodProps> = ({
                     </div>
                   )}
                 </>
-              ) : null}
-            </StyledInputContainer>
-          </div>
-          <div className="inline-container">
-            <StyledInputContainer>
-              <div className="control-label">
-                {t(
-                  '%s recipients',
-                  method === NotificationMethodOption.SlackV2
-                    ? NotificationMethodOption.Slack
-                    : method,
-                )}
-                <span className="required">*</span>
-              </div>
-              <div>
-                {[
-                  NotificationMethodOption.Email,
-                  NotificationMethodOption.Slack,
-                ].includes(method) ? (
-                  <>
+              </StyledInputContainer>
+            </div>
+          ) : null}
+          {method !== NotificationMethodOption.Webhook ? (
+            <div className="inline-container">
+              <StyledInputContainer>
+                <div className="control-label">
+                  {t(
+                    '%s recipients',
+                    method === NotificationMethodOption.SlackV2
+                      ? NotificationMethodOption.Slack
+                      : method,
+                  )}
+                  <span className="required">*</span>
+                </div>
+                <div>
+                  {[
+                    NotificationMethodOption.Email,
+                    NotificationMethodOption.Slack,
+                  ].includes(method) ? (
+                    <>
+                      <div className="input-container">
+                        <Input.TextArea
+                          name="To"
+                          data-test="recipients"
+                          value={recipientValue}
+                          onChange={onRecipientsChange}
+                        />
+                      </div>
+                      <div className="input-container">
+                        <div className="helper">
+                          {t('Recipients are separated by "," or ";"')}
+                        </div>
+                      </div>
+                    </>
+                  ) : (
+                    // for SlackV2
                     <div className="input-container">
-                      <Input.TextArea
-                        name="To"
+                      <Select
+                        ariaLabel={t('Select channels')}
+                        mode="multiple"
+                        name="recipients"
+                        value={slackRecipients}
+                        options={slackOptions}
+                        onChange={onSlackRecipientsChange}
+                        allowClear
                         data-test="recipients"
-                        value={recipientValue}
-                        onChange={onRecipientsChange}
+                        loading={isSlackChannelsLoading}
+                        allowSelectAll={false}
+                        labelInValue
+                      />
+                      <RefreshLabel
+                        onClick={() => updateSlackOptions({ force: true })}
+                        tooltipContent={t('Force refresh Slack channels list')}
+                        disabled={isSlackChannelsLoading}
                       />
                     </div>
-                    <div className="input-container">
-                      <div className="helper">
-                        {t('Recipients are separated by "," or ";"')}
-                      </div>
-                    </div>
-                  </>
-                ) : (
-                  // for SlackV2
+                  )}
+                </div>
+              </StyledInputContainer>
+            </div>
+          ) : (
+            <div className="inline-container">
+              <StyledInputContainer>
+                <div className="control-label">
+                  {t('%s URL', method)}
+                  <span className="required">*</span>
+                </div>
+                <div>
                   <div className="input-container">
-                    <Select
-                      ariaLabel={t('Select channels')}
-                      mode="multiple"
-                      name="recipients"
-                      value={slackRecipients}
-                      options={slackOptions}
-                      onChange={onSlackRecipientsChange}
-                      allowClear
+                    <Input
+                      name="To"
                       data-test="recipients"
-                      loading={isSlackChannelsLoading}
-                      allowSelectAll={false}
-                      labelInValue
-                    />
-                    <RefreshLabel
-                      onClick={() => updateSlackOptions({ force: true })}
-                      tooltipContent={t('Force refresh Slack channels list')}
-                      disabled={isSlackChannelsLoading}
+                      value={recipientValue}
+                      onChange={onRecipientsChange}
                     />
                   </div>
-                )}
-              </div>
-            </StyledInputContainer>
-          </div>
+                </div>
+              </StyledInputContainer>
+            </div>
+          )}
           {method === NotificationMethodOption.Email && (
             <StyledInputContainer>
               {/* Render "CC" input field if ccVisible is true */}
diff --git a/superset-frontend/src/features/alerts/components/RecipientIcon.tsx b/superset-frontend/src/features/alerts/components/RecipientIcon.tsx
index 9bb6ba2ba0e..698363a6cfa 100644
--- a/superset-frontend/src/features/alerts/components/RecipientIcon.tsx
+++ b/superset-frontend/src/features/alerts/components/RecipientIcon.tsx
@@ -52,6 +52,12 @@ export default function RecipientIcon({ type }: { type: string }) {
       );
       recipientIconConfig.label = NotificationMethodOption.Slack;
       break;
+    case NotificationMethodOption.Webhook:
+      recipientIconConfig.icon = (
+        <Icons.ApiOutlined css={notificationStyledIcon} iconSize="l" />
+      );
+      recipientIconConfig.label = NotificationMethodOption.Webhook;
+      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 57ed49cc6c8..0ea83f8d234 100644
--- a/superset-frontend/src/features/alerts/types.ts
+++ b/superset-frontend/src/features/alerts/types.ts
@@ -45,6 +45,7 @@ export enum NotificationMethodOption {
   Email = 'Email',
   Slack = 'Slack',
   SlackV2 = 'SlackV2',
+  Webhook = 'Webhook',
 }
 
 export type SelectValue = {
@@ -173,6 +174,7 @@ export enum RecipientIconName {
   Email = 'Email',
   Slack = 'Slack',
   SlackV2 = 'SlackV2',
+  Webhook = 'Webhook',
 }
 export interface AlertsReportsConfig {
   ALERT_REPORTS_DEFAULT_WORKING_TIMEOUT: number;
diff --git a/superset-frontend/src/features/reports/types.ts b/superset-frontend/src/features/reports/types.ts
index 637e324ca52..303a03be141 100644
--- a/superset-frontend/src/features/reports/types.ts
+++ b/superset-frontend/src/features/reports/types.ts
@@ -23,7 +23,7 @@
 export type ReportScheduleType = 'Alert' | 'Report';
 export type ReportCreationMethod = 'charts' | 'dashboards' | 'alerts_reports';
 
-export type ReportRecipientType = 'Email' | 'Slack';
+export type ReportRecipientType = 'Email' | 'Slack' | 'Webhook';
 
 export enum ReportType {
   Dashboards = 'dashboards',
diff --git a/superset/config.py b/superset/config.py
index a33294ed655..7b188370e77 100644
--- a/superset/config.py
+++ b/superset/config.py
@@ -564,6 +564,7 @@ DEFAULT_FEATURE_FLAGS: dict[str, bool] = {
     "ALERT_REPORT_TABS": False,
     "ALERT_REPORTS_FILTER": False,
     "ALERT_REPORT_SLACK_V2": False,
+    "ALERT_REPORT_WEBHOOK": False,
     "DASHBOARD_RBAC": False,
     "ENABLE_ADVANCED_DATA_TYPES": False,
     # Enabling ALERTS_ATTACH_REPORTS, the system sends email and slack message
@@ -1780,6 +1781,8 @@ ALERT_REPORTS_MAX_CUSTOM_SCREENSHOT_WIDTH = 2400
 # You can also assign a function to the config that returns the expected integer
 ALERT_MINIMUM_INTERVAL = int(timedelta(minutes=0).total_seconds())
 REPORT_MINIMUM_INTERVAL = int(timedelta(minutes=0).total_seconds())
+# Enforce HTTPS for webhook alerts/reports
+ALERT_REPORTS_WEBHOOK_HTTPS_ONLY = True
 
 # A custom prefix to use on all Alerts & Reports emails
 EMAIL_REPORTS_SUBJECT_PREFIX = "[Report] "
diff --git a/superset/reports/models.py b/superset/reports/models.py
index 20d3389a0c5..4fa573d6f1e 100644
--- a/superset/reports/models.py
+++ b/superset/reports/models.py
@@ -66,6 +66,7 @@ class ReportRecipientType(StrEnum):
     EMAIL = "Email"
     SLACK = "Slack"
     SLACKV2 = "SlackV2"
+    WEBHOOK = "Webhook"
 
 
 class ReportState(StrEnum):
diff --git a/superset/reports/notifications/__init__.py b/superset/reports/notifications/__init__.py
index 938e3934475..8cf9ea5668e 100644
--- a/superset/reports/notifications/__init__.py
+++ b/superset/reports/notifications/__init__.py
@@ -19,6 +19,7 @@ from superset.reports.notifications.base import BaseNotification, NotificationCo
 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
+from superset.reports.notifications.webhook import WebhookNotification  # noqa: F401
 
 
 def create_notification(
diff --git a/superset/reports/notifications/webhook.py b/superset/reports/notifications/webhook.py
new file mode 100644
index 00000000000..b549fca27b7
--- /dev/null
+++ b/superset/reports/notifications/webhook.py
@@ -0,0 +1,144 @@
+# 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 typing import Any
+from urllib.parse import urlparse
+
+import backoff
+import requests
+from flask import current_app
+
+from superset import feature_flag_manager
+from superset.reports.models import ReportRecipientType
+from superset.reports.notifications.base import BaseNotification
+from superset.reports.notifications.exceptions import (
+    NotificationParamException,
+    NotificationUnprocessableException,
+)
+from superset.utils import json
+from superset.utils.decorators import statsd_gauge
+
+logger = logging.getLogger(__name__)
+
+
+class WebhookNotification(BaseNotification):
+    """
+    Sends a post request to a webhook url
+    """
+
+    type = ReportRecipientType.WEBHOOK
+
+    def _get_webhook_url(self) -> str:
+        """
+        Get the webhook URL from the recipient configuration
+        :returns: The webhook URL
+        :raises NotificationParamException: If the webhook URL is not provided in the recipient configuration
+        """  # noqa: E501
+        try:
+            cfg = json.loads(self._recipient.recipient_config_json)
+            target = cfg.get("target") if isinstance(cfg, dict) else None
+            if not target:
+                raise NotificationParamException("Webhook URL is required")
+            return target
+        except (json.JSONDecodeError, KeyError, TypeError) as ex:
+            raise NotificationParamException("Webhook URL is required") from ex
+
+    def _get_req_payload(self) -> dict[str, Any]:
+        header_content = {
+            "notification_format": self._content.header_data.get("notification_format"),
+            "notification_type": self._content.header_data.get("notification_type"),
+            "notification_source": self._content.header_data.get("notification_source"),
+            "chart_id": self._content.header_data.get("chart_id"),
+            "dashboard_id": self._content.header_data.get("dashboard_id"),
+        }
+        content = {
+            "name": self._content.name,
+            "header": header_content,
+            "text": self._content.text,
+            "description": self._content.description,
+            "url": self._content.url,
+        }
+        return content
+
+    def _get_files(self) -> list[tuple[str, tuple[str, bytes, str]]]:
+        files = []
+        if self._content.csv:
+            files.append(("files", ("report.csv", self._content.csv, "text/csv")))
+        if self._content.pdf:
+            files.append(
+                ("files", ("report.pdf", self._content.pdf, "application/pdf"))
+            )
+        if self._content.screenshots:
+            for i, screenshot in enumerate(self._content.screenshots):
+                files.append(
+                    (
+                        "files",
+                        (f"screenshot_{i}.png", screenshot, "image/png"),
+                    )
+                )
+        return files
+
+    @backoff.on_exception(
+        backoff.expo, NotificationUnprocessableException, factor=10, base=2, max_tries=5
+    )
+    @statsd_gauge("reports.webhook.send")
+    def send(self) -> None:
+        if not feature_flag_manager.is_feature_enabled("ALERT_REPORT_WEBHOOK"):
+            raise NotificationUnprocessableException(
+                "Attempted to send a Webhook notification but Webhook feature flag \
+                is not enabled."
+            )
+        wh_url = self._get_webhook_url()
+        if current_app.config["ALERT_REPORTS_WEBHOOK_HTTPS_ONLY"]:
+            if urlparse(wh_url).scheme.lower() != "https":
+                raise NotificationParamException(
+                    "Webhook failed: HTTPS is required by config for webhook URLs."
+                )
+        payload = self._get_req_payload()
+        files = self._get_files()
+
+        try:
+            if files:
+                data = {}
+                for key, value in payload.items():
+                    if isinstance(value, (dict, list)):
+                        data[key] = json.dumps(value)
+                    else:
+                        data[key] = value
+
+                response = requests.post(wh_url, data=data, files=files, timeout=60)
+            else:
+                response = requests.post(wh_url, json=payload, timeout=60)
+
+            logger.info(
+                "Webhook sent to %s, status code: %s", wh_url, response.status_code
+            )
+
+            if response.status_code >= 500 or response.status_code == 429:
+                raise NotificationUnprocessableException(
+                    f"Webhook failed with status code {response.status_code}: \
+                     {response.text}"
+                )
+            if response.status_code >= 400:
+                raise NotificationParamException(
+                    f"Webhook failed with status code {response.status_code}: \
+                    {response.text}"
+                )
+
+        except requests.exceptions.RequestException as ex:
+            raise NotificationUnprocessableException(str(ex)) from ex
diff --git a/superset/views/base.py b/superset/views/base.py
index 47237eb34b4..d4178cac793 100644
--- a/superset/views/base.py
+++ b/superset/views/base.py
@@ -460,10 +460,12 @@ def cached_common_bootstrap_data(  # pylint: disable=unused-argument
             ReportRecipientType.EMAIL,
             ReportRecipientType.SLACK,
             ReportRecipientType.SLACKV2,
+            ReportRecipientType.WEBHOOK,
         ]
     else:
         frontend_config["ALERT_REPORTS_NOTIFICATION_METHODS"] = [
             ReportRecipientType.EMAIL,
+            ReportRecipientType.WEBHOOK,
         ]
 
     # verify client has google sheets installed
diff --git a/tests/unit_tests/reports/notifications/webhook_tests.py b/tests/unit_tests/reports/notifications/webhook_tests.py
new file mode 100644
index 00000000000..271ce285678
--- /dev/null
+++ b/tests/unit_tests/reports/notifications/webhook_tests.py
@@ -0,0 +1,225 @@
+# 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
+import pytest
+
+from superset.reports.notifications.exceptions import (
+    NotificationParamException,
+)
+from superset.reports.notifications.webhook import WebhookNotification
+from superset.utils.core import HeaderDataType
+
+
+@pytest.fixture
+def mock_header_data() -> HeaderDataType:
+    return {
+        "notification_format": "PNG",
+        "notification_type": "Alert",
+        "owners": [1],
+        "notification_source": None,
+        "chart_id": None,
+        "dashboard_id": None,
+        "slack_channels": None,
+        "execution_id": "test-execution-id",
+    }
+
+
+def test_get_webhook_url(mock_header_data) -> None:
+    """
+    Test the _get_webhook_url function to ensure it correctly extracts
+    the webhook URL from recipient configuration
+    """
+    from superset.reports.models import ReportRecipients, ReportRecipientType
+    from superset.reports.notifications.base import NotificationContent
+
+    content = NotificationContent(
+        name="test alert",
+        header_data=mock_header_data,
+        embedded_data=pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+        description="Test description",
+    )
+    webhook_notification = WebhookNotification(
+        recipient=ReportRecipients(
+            type=ReportRecipientType.WEBHOOK,
+            recipient_config_json='{"target": "https://example.com/webhook"}',
+        ),
+        content=content,
+    )
+
+    result = webhook_notification._get_webhook_url()
+
+    assert result == "https://example.com/webhook"
+
+
+def test_get_webhook_url_missing_url(mock_header_data) -> None:
+    """
+    Test that _get_webhook_url raises an exception when URL is missing
+    """
+    from superset.reports.models import ReportRecipients, ReportRecipientType
+    from superset.reports.notifications.base import NotificationContent
+
+    content = NotificationContent(
+        name="test alert",
+        header_data=mock_header_data,
+        description="Test description",
+    )
+    webhook_notification = WebhookNotification(
+        recipient=ReportRecipients(
+            type=ReportRecipientType.WEBHOOK,
+            recipient_config_json="{}",
+        ),
+        content=content,
+    )
+
+    with pytest.raises(NotificationParamException, match="Webhook URL is required"):
+        webhook_notification._get_webhook_url()
+
+
+def test_get_req_payload_basic(mock_header_data) -> None:
+    """
+    Test that _get_req_payload returns correct payload structure
+    """
+    from superset.reports.models import ReportRecipients, ReportRecipientType
+    from superset.reports.notifications.base import NotificationContent
+
+    content = NotificationContent(
+        name="Payload Name",
+        header_data=mock_header_data,
+        embedded_data=None,
+        description="Payload Description",
+        url="http://example.com/report",
+        text="Report Text",
+    )
+    webhook_notification = WebhookNotification(
+        recipient=ReportRecipients(
+            type=ReportRecipientType.WEBHOOK,
+            recipient_config_json='{"target": "https://webhook.com"}',
+        ),
+        content=content,
+    )
+
+    payload = webhook_notification._get_req_payload()
+
+    assert payload["name"] == "Payload Name"
+    assert payload["description"] == "Payload Description"
+    assert payload["url"] == "http://example.com/report"
+    assert payload["text"] == "Report Text"
+    assert isinstance(payload["header"], dict)
+    # Optional fields from header_data
+    assert payload["header"]["notification_format"] == "PNG"
+    assert payload["header"]["notification_type"] == "Alert"
+
+
+def test_get_files_includes_all_content_types(mock_header_data) -> None:
+    """
+    Test that _get_files correctly includes csv, pdf, and multiple screenshot attachments
+    """  # noqa: E501
+
+    from superset.reports.models import ReportRecipients, ReportRecipientType
+    from superset.reports.notifications.base import NotificationContent
+
+    csv_bytes = b"col1,col2\n1,2"
+    pdf_bytes = b"%PDF-1.4"
+    screenshots = [b"fakeimg1", b"fakeimg2"]
+
+    content = NotificationContent(
+        name="file test",
+        header_data=mock_header_data,
+        csv=csv_bytes,
+        pdf=pdf_bytes,
+        screenshots=screenshots,
+        description="files test",
+    )
+    webhook_notification = WebhookNotification(
+        recipient=ReportRecipients(
+            type=ReportRecipientType.WEBHOOK,
+            recipient_config_json='{"target": "https://webhook.com"}',
+        ),
+        content=content,
+    )
+    files = webhook_notification._get_files()
+    # There should be 1 csv, 1 pdf, and 2 screenshots = 4 files total
+    assert len(files) == 4
+
+    file_names = [file_info[1][0] for file_info in files]
+    assert "report.csv" in file_names
+    assert "report.pdf" in file_names
+    assert "screenshot_0.png" in file_names
+    assert "screenshot_1.png" in file_names
+
+    mime_types = [file_info[1][2] for file_info in files]
+    assert "text/csv" in mime_types
+    assert "application/pdf" in mime_types
+    assert mime_types.count("image/png") == 2
+
+
+def test_get_files_empty_when_no_content(mock_header_data) -> None:
+    """
+    Test that _get_files returns empty list when no files present
+    """
+    from superset.reports.models import ReportRecipients, ReportRecipientType
+    from superset.reports.notifications.base import NotificationContent
+
+    content = NotificationContent(
+        name="no files",
+        header_data=mock_header_data,
+        description="no files test",
+    )
+    webhook_notification = WebhookNotification(
+        recipient=ReportRecipients(
+            type=ReportRecipientType.WEBHOOK,
+            recipient_config_json='{"target": "https://webhook.com"}',
+        ),
+        content=content,
+    )
+    files = webhook_notification._get_files()
+    assert files == []
+
+
+def test_send_http_only_https_check(monkeypatch, mock_header_data) -> None:
+    """
+    Test send raises when URL is not HTTPS and config enforces HTTPS only
+    """
+    from superset.reports.models import ReportRecipients, ReportRecipientType
+    from superset.reports.notifications.base import NotificationContent
+
+    content = NotificationContent(
+        name="test alert", header_data=mock_header_data, description="Test description"
+    )
+    webhook_notification = WebhookNotification(
+        recipient=ReportRecipients(
+            type=ReportRecipientType.WEBHOOK,
+            recipient_config_json='{"target": "http://notsecure.com/webhook"}',
+        ),
+        content=content,
+    )
+
+    class MockCurrentApp:
+        config = {"ALERT_REPORTS_WEBHOOK_HTTPS_ONLY": True}
+
+    monkeypatch.setattr(
+        "superset.reports.notifications.webhook.current_app", MockCurrentApp
+    )
+    monkeypatch.setattr(
+        "superset.reports.notifications.webhook.feature_flag_manager.is_feature_enabled",
+        lambda flag: True,
+    )
+
+    with pytest.raises(NotificationParamException, match="HTTPS is required by config"):
+        webhook_notification.send()