diff --git a/packages/browser-integration-tests/suites/replay/slowClick/clickTargets/test.ts b/packages/browser-integration-tests/suites/replay/slowClick/clickTargets/test.ts
new file mode 100644
index 000000000000..dfa1581d4704
--- /dev/null
+++ b/packages/browser-integration-tests/suites/replay/slowClick/clickTargets/test.ts
@@ -0,0 +1,139 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getCustomRecordingEvents, shouldSkipReplayTest, waitForReplayRequest } from '../../../../utils/replayHelpers';
+
+[
+  {
+    id: 'link',
+    slowClick: true,
+  },
+  {
+    id: 'linkExternal',
+    slowClick: false,
+  },
+  {
+    id: 'linkDownload',
+    slowClick: false,
+  },
+  {
+    id: 'inputButton',
+    slowClick: true,
+  },
+  {
+    id: 'inputSubmit',
+    slowClick: true,
+  },
+  {
+    id: 'inputText',
+    slowClick: false,
+  },
+].forEach(({ id, slowClick }) => {
+  if (slowClick) {
+    sentryTest(`slow click is captured for ${id}`, async ({ getLocalTestUrl, page }) => {
+      if (shouldSkipReplayTest()) {
+        sentryTest.skip();
+      }
+
+      const reqPromise0 = waitForReplayRequest(page, 0);
+
+      await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+        return route.fulfill({
+          status: 200,
+          contentType: 'application/json',
+          body: JSON.stringify({ id: 'test-id' }),
+        });
+      });
+
+      const url = await getLocalTestUrl({ testDir: __dirname });
+
+      await page.goto(url);
+      await reqPromise0;
+
+      const reqPromise1 = waitForReplayRequest(page, (event, res) => {
+        const { breadcrumbs } = getCustomRecordingEvents(res);
+
+        return breadcrumbs.some(breadcrumb => breadcrumb.category === 'ui.slowClickDetected');
+      });
+
+      await page.click(`#${id}`);
+
+      const { breadcrumbs } = getCustomRecordingEvents(await reqPromise1);
+
+      const slowClickBreadcrumbs = breadcrumbs.filter(breadcrumb => breadcrumb.category === 'ui.slowClickDetected');
+
+      expect(slowClickBreadcrumbs).toEqual([
+        {
+          category: 'ui.slowClickDetected',
+          data: {
+            endReason: 'timeout',
+            node: {
+              attributes: expect.objectContaining({
+                id,
+              }),
+              id: expect.any(Number),
+              tagName: expect.any(String),
+              textContent: expect.any(String),
+            },
+            nodeId: expect.any(Number),
+            timeAfterClickMs: expect.any(Number),
+            url: expect.any(String),
+          },
+          message: expect.any(String),
+          timestamp: expect.any(Number),
+        },
+      ]);
+    });
+  } else {
+    sentryTest(`slow click is not captured for ${id}`, async ({ getLocalTestUrl, page }) => {
+      if (shouldSkipReplayTest()) {
+        sentryTest.skip();
+      }
+
+      const reqPromise0 = waitForReplayRequest(page, 0);
+
+      await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+        return route.fulfill({
+          status: 200,
+          contentType: 'application/json',
+          body: JSON.stringify({ id: 'test-id' }),
+        });
+      });
+
+      const url = await getLocalTestUrl({ testDir: __dirname });
+
+      await page.goto(url);
+      await reqPromise0;
+
+      const reqPromise1 = waitForReplayRequest(page, (event, res) => {
+        const { breadcrumbs } = getCustomRecordingEvents(res);
+
+        return breadcrumbs.some(breadcrumb => breadcrumb.category === 'ui.click');
+      });
+
+      await page.click(`#${id}`);
+
+      const { breadcrumbs } = getCustomRecordingEvents(await reqPromise1);
+
+      expect(breadcrumbs).toEqual([
+        {
+          category: 'ui.click',
+          data: {
+            node: {
+              attributes: expect.objectContaining({
+                id,
+              }),
+              id: expect.any(Number),
+              tagName: expect.any(String),
+              textContent: expect.any(String),
+            },
+            nodeId: expect.any(Number),
+          },
+          message: expect.any(String),
+          timestamp: expect.any(Number),
+          type: 'default',
+        },
+      ]);
+    });
+  }
+});
diff --git a/packages/browser-integration-tests/suites/replay/slowClick/ignore/test.ts b/packages/browser-integration-tests/suites/replay/slowClick/ignore/test.ts
new file mode 100644
index 000000000000..c3cdb6e35c65
--- /dev/null
+++ b/packages/browser-integration-tests/suites/replay/slowClick/ignore/test.ts
@@ -0,0 +1,56 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getCustomRecordingEvents, shouldSkipReplayTest, waitForReplayRequest } from '../../../../utils/replayHelpers';
+
+sentryTest('click is ignored on ignoreSelectors', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipReplayTest()) {
+    sentryTest.skip();
+  }
+
+  const reqPromise0 = waitForReplayRequest(page, 0);
+
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.goto(url);
+  await reqPromise0;
+
+  const reqPromise1 = waitForReplayRequest(page, (event, res) => {
+    const { breadcrumbs } = getCustomRecordingEvents(res);
+
+    return breadcrumbs.some(breadcrumb => breadcrumb.category === 'ui.click');
+  });
+
+  await page.click('#mutationIgnoreButton');
+
+  const { breadcrumbs } = getCustomRecordingEvents(await reqPromise1);
+
+  expect(breadcrumbs).toEqual([
+    {
+      category: 'ui.click',
+      data: {
+        node: {
+          attributes: {
+            class: 'ignore-class',
+            id: 'mutationIgnoreButton',
+          },
+          id: expect.any(Number),
+          tagName: 'button',
+          textContent: '******* ****** ****',
+        },
+        nodeId: expect.any(Number),
+      },
+      message: 'body > button#mutationIgnoreButton.ignore-class',
+      timestamp: expect.any(Number),
+      type: 'default',
+    },
+  ]);
+});
diff --git a/packages/browser-integration-tests/suites/replay/slowClick/init.js b/packages/browser-integration-tests/suites/replay/slowClick/init.js
new file mode 100644
index 000000000000..2fc5dab81aea
--- /dev/null
+++ b/packages/browser-integration-tests/suites/replay/slowClick/init.js
@@ -0,0 +1,24 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+window.Replay = new Sentry.Replay({
+  flushMinDelay: 500,
+  flushMaxDelay: 500,
+  _experiments: {
+    slowClicks: {
+      threshold: 300,
+      scrollThreshold: 300,
+      timeout: 2000,
+      ignoreSelectors: ['.ignore-class', '[ignore-attribute]'],
+    },
+  },
+});
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  sampleRate: 0,
+  replaysSessionSampleRate: 1.0,
+  replaysOnErrorSampleRate: 0.0,
+
+  integrations: [window.Replay],
+});
diff --git a/packages/browser-integration-tests/suites/replay/slowClick/mutation/test.ts b/packages/browser-integration-tests/suites/replay/slowClick/mutation/test.ts
new file mode 100644
index 000000000000..2ed458213955
--- /dev/null
+++ b/packages/browser-integration-tests/suites/replay/slowClick/mutation/test.ts
@@ -0,0 +1,219 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getCustomRecordingEvents, shouldSkipReplayTest, waitForReplayRequest } from '../../../../utils/replayHelpers';
+
+sentryTest('mutation after threshold results in slow click', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipReplayTest()) {
+    sentryTest.skip();
+  }
+
+  const reqPromise0 = waitForReplayRequest(page, 0);
+
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.goto(url);
+  await reqPromise0;
+
+  const reqPromise1 = waitForReplayRequest(page, (event, res) => {
+    const { breadcrumbs } = getCustomRecordingEvents(res);
+
+    return breadcrumbs.some(breadcrumb => breadcrumb.category === 'ui.slowClickDetected');
+  });
+
+  // Trigger this twice, sometimes this was flaky otherwise...
+  await page.click('#mutationButton');
+  await page.click('#mutationButton');
+
+  const { breadcrumbs } = getCustomRecordingEvents(await reqPromise1);
+
+  const slowClickBreadcrumbs = breadcrumbs.filter(breadcrumb => breadcrumb.category === 'ui.slowClickDetected');
+
+  expect(slowClickBreadcrumbs).toEqual([
+    {
+      category: 'ui.slowClickDetected',
+      data: {
+        endReason: 'mutation',
+        node: {
+          attributes: {
+            id: 'mutationButton',
+          },
+          id: expect.any(Number),
+          tagName: 'button',
+          textContent: '******* ********',
+        },
+        nodeId: expect.any(Number),
+        timeAfterClickMs: expect.any(Number),
+        url: 'http://sentry-test.io/index.html',
+      },
+      message: 'body > button#mutationButton',
+      timestamp: expect.any(Number),
+    },
+  ]);
+
+  expect(slowClickBreadcrumbs[0]?.data?.timeAfterClickMs).toBeGreaterThan(300);
+  expect(slowClickBreadcrumbs[0]?.data?.timeAfterClickMs).toBeLessThan(2000);
+});
+
+sentryTest('immediate mutation does not trigger slow click', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipReplayTest()) {
+    sentryTest.skip();
+  }
+
+  const reqPromise0 = waitForReplayRequest(page, 0);
+
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.goto(url);
+  await reqPromise0;
+
+  const reqPromise1 = waitForReplayRequest(page, (event, res) => {
+    const { breadcrumbs } = getCustomRecordingEvents(res);
+
+    return breadcrumbs.some(breadcrumb => breadcrumb.category === 'ui.click');
+  });
+
+  await page.click('#mutationButtonImmediately');
+
+  const { breadcrumbs } = getCustomRecordingEvents(await reqPromise1);
+
+  expect(breadcrumbs).toEqual([
+    {
+      category: 'ui.click',
+      data: {
+        node: {
+          attributes: {
+            id: 'mutationButtonImmediately',
+          },
+          id: expect.any(Number),
+          tagName: 'button',
+          textContent: '******* ******** ***********',
+        },
+        nodeId: expect.any(Number),
+      },
+      message: 'body > button#mutationButtonImmediately',
+      timestamp: expect.any(Number),
+      type: 'default',
+    },
+  ]);
+});
+
+sentryTest('inline click handler does not trigger slow click', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipReplayTest()) {
+    sentryTest.skip();
+  }
+
+  const reqPromise0 = waitForReplayRequest(page, 0);
+
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.goto(url);
+  await reqPromise0;
+
+  const reqPromise1 = waitForReplayRequest(page, (event, res) => {
+    const { breadcrumbs } = getCustomRecordingEvents(res);
+
+    return breadcrumbs.some(breadcrumb => breadcrumb.category === 'ui.click');
+  });
+
+  await page.click('#mutationButtonInline');
+
+  const { breadcrumbs } = getCustomRecordingEvents(await reqPromise1);
+
+  expect(breadcrumbs).toEqual([
+    {
+      category: 'ui.click',
+      data: {
+        node: {
+          attributes: {
+            id: 'mutationButtonInline',
+          },
+          id: expect.any(Number),
+          tagName: 'button',
+          textContent: '******* ******** ***********',
+        },
+        nodeId: expect.any(Number),
+      },
+      message: 'body > button#mutationButtonInline',
+      timestamp: expect.any(Number),
+      type: 'default',
+    },
+  ]);
+});
+
+sentryTest('click is not ignored on div', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipReplayTest()) {
+    sentryTest.skip();
+  }
+
+  const reqPromise0 = waitForReplayRequest(page, 0);
+
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.goto(url);
+  await reqPromise0;
+
+  const reqPromise1 = waitForReplayRequest(page, (event, res) => {
+    const { breadcrumbs } = getCustomRecordingEvents(res);
+
+    return breadcrumbs.some(breadcrumb => breadcrumb.category === 'ui.slowClickDetected');
+  });
+
+  await page.click('#mutationDiv');
+
+  const { breadcrumbs } = getCustomRecordingEvents(await reqPromise1);
+
+  expect(breadcrumbs.filter(({ category }) => category === 'ui.slowClickDetected')).toEqual([
+    {
+      category: 'ui.slowClickDetected',
+      data: {
+        endReason: 'mutation',
+        node: {
+          attributes: {
+            id: 'mutationDiv',
+          },
+          id: expect.any(Number),
+          tagName: 'div',
+          textContent: '******* ********',
+        },
+        nodeId: expect.any(Number),
+        timeAfterClickMs: expect.any(Number),
+        url: 'http://sentry-test.io/index.html',
+      },
+      message: 'body > div#mutationDiv',
+      timestamp: expect.any(Number),
+    },
+  ]);
+});
diff --git a/packages/browser-integration-tests/suites/replay/slowClick/scroll/test.ts b/packages/browser-integration-tests/suites/replay/slowClick/scroll/test.ts
new file mode 100644
index 000000000000..f7f705ce5670
--- /dev/null
+++ b/packages/browser-integration-tests/suites/replay/slowClick/scroll/test.ts
@@ -0,0 +1,110 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getCustomRecordingEvents, shouldSkipReplayTest, waitForReplayRequest } from '../../../../utils/replayHelpers';
+
+sentryTest('immediate scroll does not trigger slow click', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipReplayTest()) {
+    sentryTest.skip();
+  }
+
+  const reqPromise0 = waitForReplayRequest(page, 0);
+
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.goto(url);
+  await reqPromise0;
+
+  const reqPromise1 = waitForReplayRequest(page, (event, res) => {
+    const { breadcrumbs } = getCustomRecordingEvents(res);
+
+    return breadcrumbs.some(breadcrumb => breadcrumb.category === 'ui.click');
+  });
+
+  await page.click('#scrollButton');
+
+  const { breadcrumbs } = getCustomRecordingEvents(await reqPromise1);
+
+  expect(breadcrumbs).toEqual([
+    {
+      category: 'ui.click',
+      data: {
+        node: {
+          attributes: {
+            id: 'scrollButton',
+          },
+          id: expect.any(Number),
+          tagName: 'button',
+          textContent: '******* ******',
+        },
+        nodeId: expect.any(Number),
+      },
+      message: 'body > button#scrollButton',
+      timestamp: expect.any(Number),
+      type: 'default',
+    },
+  ]);
+});
+
+sentryTest('late scroll triggers slow click', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipReplayTest()) {
+    sentryTest.skip();
+  }
+
+  const reqPromise0 = waitForReplayRequest(page, 0);
+
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.goto(url);
+  await reqPromise0;
+
+  const reqPromise1 = waitForReplayRequest(page, (event, res) => {
+    const { breadcrumbs } = getCustomRecordingEvents(res);
+
+    return breadcrumbs.some(breadcrumb => breadcrumb.category === 'ui.slowClickDetected');
+  });
+
+  await page.click('#scrollLateButton');
+
+  const { breadcrumbs } = getCustomRecordingEvents(await reqPromise1);
+
+  const slowClickBreadcrumbs = breadcrumbs.filter(breadcrumb => breadcrumb.category === 'ui.slowClickDetected');
+
+  expect(slowClickBreadcrumbs).toEqual([
+    {
+      category: 'ui.slowClickDetected',
+      data: {
+        endReason: 'timeout',
+        node: {
+          attributes: {
+            id: 'scrollLateButton',
+          },
+          id: expect.any(Number),
+          tagName: 'button',
+          textContent: '******* ****** ****',
+        },
+        nodeId: expect.any(Number),
+        timeAfterClickMs: expect.any(Number),
+        url: 'http://sentry-test.io/index.html',
+      },
+      message: 'body > button#scrollLateButton',
+      timestamp: expect.any(Number),
+    },
+  ]);
+});
diff --git a/packages/browser-integration-tests/suites/replay/slowClick/template.html b/packages/browser-integration-tests/suites/replay/slowClick/template.html
new file mode 100644
index 000000000000..07e12cc088f3
--- /dev/null
+++ b/packages/browser-integration-tests/suites/replay/slowClick/template.html
@@ -0,0 +1,83 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <button id="mutationButton">Trigger mutation</button>
+    <div id="mutationDiv">Trigger mutation</div>
+    <button id="mutationButtonImmediately">Trigger mutation immediately</button>
+    <button
+      id="mutationButtonInline"
+      onclick="() =>  document.getElementById('out').innerHTML += 'mutationButtonInline clicked<br>'"
+    >
+      Trigger mutation immediately
+    </button>
+    <button id="mutationButtonLate">Trigger mutation late</button>
+    <button id="consoleLogButton">Trigger console log</button>
+    <button id="scrollButton">Trigger scroll</button>
+    <button id="scrollLateButton">Trigger scroll late</button>
+    <button id="mutationIgnoreButton" class="ignore-class">Trigger scroll late</button>
+
+    <a href="#" id="link">Link</a>
+    <a href="#" target="_blank" id="linkExternal">Link external</a>
+    <a href="" download id="linkDownload">Link download</a>
+    <input type="button" id="inputButton" value="Input button" />
+    <input type="submit" id="inputSubmit" value="Input submit" />
+    <input type="text" id="inputText" />
+
+    <h1 id="h1">Heading</h1>
+
+    <div id="out" style="min-height: 1000px"></div>
+
+    <h1 id="h2">Bottom</h1>
+
+    <script>
+      document.getElementById('mutationButton').addEventListener('click', () => {
+        setTimeout(() => {
+          document.getElementById('out').innerHTML += 'mutationButton clicked<br>';
+        }, 400);
+      });
+      document.getElementById('mutationIgnoreButton').addEventListener('click', () => {
+        setTimeout(() => {
+          document.getElementById('out').innerHTML += 'mutationIgnoreButton clicked<br>';
+        }, 400);
+      });
+      document.getElementById('mutationDiv').addEventListener('click', () => {
+        setTimeout(() => {
+          document.getElementById('out').innerHTML += 'mutationDiv clicked<br>';
+        }, 400);
+      });
+      document.getElementById('mutationButtonLate').addEventListener('click', () => {
+        setTimeout(() => {
+          document.getElementById('out').innerHTML += 'mutationButtonLate clicked<br>';
+        }, 3000);
+      });
+      document.getElementById('mutationButtonImmediately').addEventListener('click', () => {
+        document.getElementById('out').innerHTML += 'mutationButtonImmediately clicked<br>';
+      });
+      document.getElementById('scrollButton').addEventListener('click', () => {
+        document.getElementById('h2').scrollIntoView({ behavior: 'smooth' });
+      });
+      document.getElementById('scrollLateButton').addEventListener('click', () => {
+        setTimeout(() => {
+          document.getElementById('h2').scrollIntoView({ behavior: 'smooth' });
+        }, 400);
+      });
+      document.getElementById('consoleLogButton').addEventListener('click', () => {
+        setTimeout(() => {
+          console.log('DONE');
+        }, 400);
+      });
+
+      // Do nothing on these elements
+      document
+        .querySelectorAll('#link,#linkExternal,#linkDownload,#inputButton,#inputSubmit,#inputText')
+        .forEach(link => {
+          link.addEventListener('click', e => {
+            e.preventDefault();
+          });
+        });
+    </script>
+  </body>
+</html>
diff --git a/packages/browser-integration-tests/suites/replay/slowClick/timeout/test.ts b/packages/browser-integration-tests/suites/replay/slowClick/timeout/test.ts
new file mode 100644
index 000000000000..e3fba57cd2b9
--- /dev/null
+++ b/packages/browser-integration-tests/suites/replay/slowClick/timeout/test.ts
@@ -0,0 +1,114 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getCustomRecordingEvents, shouldSkipReplayTest, waitForReplayRequest } from '../../../../utils/replayHelpers';
+
+sentryTest('mutation after timeout results in slow click', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipReplayTest()) {
+    sentryTest.skip();
+  }
+
+  const reqPromise0 = waitForReplayRequest(page, 0);
+
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.goto(url);
+  await reqPromise0;
+
+  const reqPromise1 = waitForReplayRequest(page, (event, res) => {
+    const { breadcrumbs } = getCustomRecordingEvents(res);
+
+    return breadcrumbs.some(breadcrumb => breadcrumb.category === 'ui.slowClickDetected');
+  });
+
+  await page.click('#mutationButtonLate');
+
+  const { breadcrumbs } = getCustomRecordingEvents(await reqPromise1);
+
+  const slowClickBreadcrumbs = breadcrumbs.filter(breadcrumb => breadcrumb.category === 'ui.slowClickDetected');
+
+  expect(slowClickBreadcrumbs).toEqual([
+    {
+      category: 'ui.slowClickDetected',
+      data: {
+        endReason: 'timeout',
+        node: {
+          attributes: {
+            id: 'mutationButtonLate',
+          },
+          id: expect.any(Number),
+          tagName: 'button',
+          textContent: '******* ******** ****',
+        },
+        nodeId: expect.any(Number),
+        timeAfterClickMs: 2000,
+        url: 'http://sentry-test.io/index.html',
+      },
+      message: 'body > button#mutationButtonLate',
+      timestamp: expect.any(Number),
+    },
+  ]);
+});
+
+sentryTest('console.log results in slow click', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipReplayTest()) {
+    sentryTest.skip();
+  }
+
+  const reqPromise0 = waitForReplayRequest(page, 0);
+
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.goto(url);
+  await reqPromise0;
+
+  const reqPromise1 = waitForReplayRequest(page, (event, res) => {
+    const { breadcrumbs } = getCustomRecordingEvents(res);
+
+    return breadcrumbs.some(breadcrumb => breadcrumb.category === 'ui.slowClickDetected');
+  });
+
+  await page.click('#consoleLogButton');
+
+  const { breadcrumbs } = getCustomRecordingEvents(await reqPromise1);
+
+  const slowClickBreadcrumbs = breadcrumbs.filter(breadcrumb => breadcrumb.category === 'ui.slowClickDetected');
+
+  expect(slowClickBreadcrumbs).toEqual([
+    {
+      category: 'ui.slowClickDetected',
+      data: {
+        endReason: 'timeout',
+        node: {
+          attributes: {
+            id: 'consoleLogButton',
+          },
+          id: expect.any(Number),
+          tagName: 'button',
+          textContent: '******* ******* ***',
+        },
+        nodeId: expect.any(Number),
+        timeAfterClickMs: 2000,
+        url: 'http://sentry-test.io/index.html',
+      },
+      message: 'body > button#consoleLogButton',
+      timestamp: expect.any(Number),
+    },
+  ]);
+});
diff --git a/packages/replay/src/coreHandlers/handleDom.ts b/packages/replay/src/coreHandlers/handleDom.ts
index 00d274760511..1e46a18864d5 100644
--- a/packages/replay/src/coreHandlers/handleDom.ts
+++ b/packages/replay/src/coreHandlers/handleDom.ts
@@ -3,8 +3,9 @@ import { NodeType } from '@sentry-internal/rrweb-snapshot';
 import type { Breadcrumb } from '@sentry/types';
 import { htmlTreeAsString } from '@sentry/utils';
 
-import type { ReplayContainer } from '../types';
+import type { ReplayContainer, SlowClickConfig } from '../types';
 import { createBreadcrumb } from '../util/createBreadcrumb';
+import { detectSlowClick } from './handleSlowClick';
 import { addBreadcrumbEvent } from './util/addBreadcrumbEvent';
 import { getAttributesToRecord } from './util/getAttributesToRecord';
 
@@ -13,9 +14,21 @@ export interface DomHandlerData {
   event: Node | { target: EventTarget };
 }
 
-export const handleDomListener: (replay: ReplayContainer) => (handlerData: DomHandlerData) => void =
-  (replay: ReplayContainer) =>
-  (handlerData: DomHandlerData): void => {
+export const handleDomListener: (replay: ReplayContainer) => (handlerData: DomHandlerData) => void = (
+  replay: ReplayContainer,
+) => {
+  const slowClickExperiment = replay.getOptions()._experiments.slowClicks;
+
+  const slowClickConfig: SlowClickConfig | undefined = slowClickExperiment
+    ? {
+        threshold: slowClickExperiment.threshold,
+        timeout: slowClickExperiment.timeout,
+        scrollTimeout: slowClickExperiment.scrollTimeout,
+        ignoreSelector: slowClickExperiment.ignoreSelectors ? slowClickExperiment.ignoreSelectors.join(',') : '',
+      }
+    : undefined;
+
+  return (handlerData: DomHandlerData): void => {
     if (!replay.isEnabled()) {
       return;
     }
@@ -26,8 +39,21 @@ export const handleDomListener: (replay: ReplayContainer) => (handlerData: DomHa
       return;
     }
 
+    const isClick = handlerData.name === 'click';
+    const event = isClick && (handlerData.event as PointerEvent);
+    // Ignore clicks if ctrl/alt/meta keys are held down as they alter behavior of clicks (e.g. open in new tab)
+    if (isClick && slowClickConfig && event && !event.altKey && !event.metaKey && !event.ctrlKey) {
+      detectSlowClick(
+        replay,
+        slowClickConfig,
+        result as Breadcrumb & { timestamp: number },
+        getClickTargetNode(handlerData.event) as HTMLElement,
+      );
+    }
+
     addBreadcrumbEvent(replay, result);
   };
+};
 
 /** Get the base DOM breadcrumb. */
 export function getBaseDomBreadcrumb(target: Node | INode | null, message: string): Breadcrumb {
diff --git a/packages/replay/src/coreHandlers/handleSlowClick.ts b/packages/replay/src/coreHandlers/handleSlowClick.ts
new file mode 100644
index 000000000000..c8a867209ffd
--- /dev/null
+++ b/packages/replay/src/coreHandlers/handleSlowClick.ts
@@ -0,0 +1,144 @@
+import type { Breadcrumb } from '@sentry/types';
+
+import { WINDOW } from '../constants';
+import type { ReplayContainer, SlowClickConfig } from '../types';
+import { addBreadcrumbEvent } from './util/addBreadcrumbEvent';
+
+type ClickBreadcrumb = Breadcrumb & {
+  timestamp: number;
+};
+
+/**
+ * Detect a slow click on a button/a tag,
+ * and potentially create a corresponding breadcrumb.
+ */
+export function detectSlowClick(
+  replay: ReplayContainer,
+  config: SlowClickConfig,
+  clickBreadcrumb: ClickBreadcrumb,
+  node: HTMLElement,
+): void {
+  if (ignoreElement(node, config)) {
+    return;
+  }
+
+  /*
+    We consider a slow click a click on a button/a, which does not trigger one of:
+     - DOM mutation
+     - Scroll (within 100ms)
+     Within the given threshold time.
+     After time timeout time, we stop listening and mark it as a slow click anyhow.
+  */
+
+  let cleanup: () => void = () => {
+    // replaced further down
+  };
+
+  // After timeout time, def. consider this a slow click, and stop watching for mutations
+  const timeout = setTimeout(() => {
+    handleSlowClick(replay, clickBreadcrumb, config.timeout, 'timeout');
+    cleanup();
+  }, config.timeout);
+
+  const mutationHandler = (): void => {
+    maybeHandleSlowClick(replay, clickBreadcrumb, config.threshold, config.timeout, 'mutation');
+    cleanup();
+  };
+
+  const scrollHandler = (): void => {
+    maybeHandleSlowClick(replay, clickBreadcrumb, config.scrollTimeout, config.timeout, 'scroll');
+    cleanup();
+  };
+
+  const obs = new MutationObserver(mutationHandler);
+
+  obs.observe(WINDOW.document.documentElement, {
+    attributes: true,
+    characterData: true,
+    childList: true,
+    subtree: true,
+  });
+
+  WINDOW.addEventListener('scroll', scrollHandler);
+
+  // Stop listening to scroll timeouts early
+  const scrollTimeout = setTimeout(() => {
+    WINDOW.removeEventListener('scroll', scrollHandler);
+  }, config.scrollTimeout);
+
+  cleanup = (): void => {
+    clearTimeout(timeout);
+    clearTimeout(scrollTimeout);
+    obs.disconnect();
+    WINDOW.removeEventListener('scroll', scrollHandler);
+  };
+}
+
+function maybeHandleSlowClick(
+  replay: ReplayContainer,
+  clickBreadcrumb: ClickBreadcrumb,
+  threshold: number,
+  timeout: number,
+  endReason: string,
+): boolean {
+  const now = Date.now();
+  const timeAfterClickMs = now - clickBreadcrumb.timestamp * 1000;
+
+  if (timeAfterClickMs > threshold) {
+    handleSlowClick(replay, clickBreadcrumb, Math.min(timeAfterClickMs, timeout), endReason);
+    return true;
+  }
+
+  return false;
+}
+
+function handleSlowClick(
+  replay: ReplayContainer,
+  clickBreadcrumb: ClickBreadcrumb,
+  timeAfterClickMs: number,
+  endReason: string,
+): void {
+  const breadcrumb = {
+    message: clickBreadcrumb.message,
+    timestamp: clickBreadcrumb.timestamp,
+    category: 'ui.slowClickDetected',
+    data: {
+      ...clickBreadcrumb.data,
+      url: WINDOW.location.href,
+      // TODO FN: add parametrized route, when possible
+      timeAfterClickMs,
+      endReason,
+    },
+  };
+
+  addBreadcrumbEvent(replay, breadcrumb);
+}
+
+const SLOW_CLICK_IGNORE_TAGS = ['SELECT', 'OPTION'];
+
+function ignoreElement(node: HTMLElement, config: SlowClickConfig): boolean {
+  // If <input> tag, we only want to consider input[type='submit'] & input[type='button']
+  if (node.tagName === 'INPUT' && !['submit', 'button'].includes(node.getAttribute('type') || '')) {
+    return true;
+  }
+
+  if (SLOW_CLICK_IGNORE_TAGS.includes(node.tagName)) {
+    return true;
+  }
+
+  // If <a> tag, detect special variants that may not lead to an action
+  // If target !== _self, we may open the link somewhere else, which would lead to no action
+  // Also, when downloading a file, we may not leave the page, but still not trigger an action
+  if (
+    node.tagName === 'A' &&
+    (node.hasAttribute('download') || (node.hasAttribute('target') && node.getAttribute('target') !== '_self'))
+  ) {
+    return true;
+  }
+
+  if (config.ignoreSelector && node.matches(config.ignoreSelector)) {
+    return true;
+  }
+
+  return false;
+}
diff --git a/packages/replay/src/types.ts b/packages/replay/src/types.ts
index aef61f57a07a..12900dc22e74 100644
--- a/packages/replay/src/types.ts
+++ b/packages/replay/src/types.ts
@@ -279,6 +279,12 @@ export interface ReplayPluginOptions extends ReplayNetworkOptions {
     traceInternals: boolean;
     mutationLimit: number;
     mutationBreadcrumbLimit: number;
+    slowClicks: {
+      threshold: number;
+      timeout: number;
+      scrollTimeout: number;
+      ignoreSelectors: string[];
+    };
   }>;
 }
 
@@ -583,3 +589,10 @@ export type ReplayNetworkRequestData = {
   request?: ReplayNetworkRequestOrResponse;
   response?: ReplayNetworkRequestOrResponse;
 };
+
+export interface SlowClickConfig {
+  threshold: number;
+  timeout: number;
+  scrollTimeout: number;
+  ignoreSelector: string;
+}