diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index cbc80ec59f33..56f61126a45a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -815,6 +815,7 @@ jobs:
             'create-react-app',
             'create-next-app',
             'create-remix-app',
+            'create-remix-app-v2',
             'nextjs-app-dir',
             'react-create-hash-router',
             'react-router-6-use-routes',
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/.eslintrc.js b/packages/e2e-tests/test-applications/create-remix-app-v2/.eslintrc.js
new file mode 100644
index 000000000000..f2faf1470fd8
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/.eslintrc.js
@@ -0,0 +1,4 @@
+/** @type {import('eslint').Linter.Config} */
+module.exports = {
+  extends: ['@remix-run/eslint-config', '@remix-run/eslint-config/node'],
+};
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/.gitignore b/packages/e2e-tests/test-applications/create-remix-app-v2/.gitignore
new file mode 100644
index 000000000000..3f7bf98da3e1
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/.gitignore
@@ -0,0 +1,6 @@
+node_modules
+
+/.cache
+/build
+/public/build
+.env
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/.npmrc b/packages/e2e-tests/test-applications/create-remix-app-v2/.npmrc
new file mode 100644
index 000000000000..c6b3ef9b3eaa
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/.npmrc
@@ -0,0 +1,2 @@
+@sentry:registry=http://localhost:4873
+@sentry-internal:registry=http://localhost:4873
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/README.md b/packages/e2e-tests/test-applications/create-remix-app-v2/README.md
new file mode 100644
index 000000000000..54336d746713
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/README.md
@@ -0,0 +1,61 @@
+# Welcome to Remix!
+
+- [Remix Docs](https://remix.run/docs)
+
+## Development
+
+From your terminal:
+
+```sh
+npm run dev
+```
+
+This starts your app in development mode, rebuilding assets on file changes.
+
+## Deployment
+
+First, build your app for production:
+
+```sh
+npm run build
+```
+
+Then run the app in production mode:
+
+```sh
+npm start
+```
+
+Now you'll need to pick a host to deploy it to.
+
+### DIY
+
+If you're familiar with deploying node applications, the built-in Remix app server is production-ready.
+
+Make sure to deploy the output of `remix build`
+
+- `build/`
+- `public/build/`
+
+### Using a Template
+
+When you ran `npx create-remix@latest` there were a few choices for hosting. You can run that again to create a new
+project, then copy over relevant code/assets from your current app to the new project that's pre-configured for your
+target server.
+
+Most importantly, this means everything in the `app/` directory, but if you've further customized your current
+application outside of there it may also include:
+
+- Any assets you've added/updated in `public/`
+- Any updated versions of root files such as `.eslintrc.js`, etc.
+
+```sh
+cd ..
+# create a new project, and pick a pre-configured host
+npx create-remix@latest
+cd my-new-remix-app
+# remove the new project's app (not the old one!)
+rm -rf app
+# copy your app over
+cp -R ../my-old-remix-app/app app
+```
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/app/entry.client.tsx b/packages/e2e-tests/test-applications/create-remix-app-v2/app/entry.client.tsx
new file mode 100644
index 000000000000..605d8e792d23
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/app/entry.client.tsx
@@ -0,0 +1,49 @@
+/**
+ * By default, Remix will handle hydrating your app on the client for you.
+ * You are free to delete this file if you'd like to, but if you ever want it revealed again, you can run `npx remix reveal` ✨
+ * For more information, see https://remix.run/file-conventions/entry.client
+ */
+
+import { RemixBrowser, useLocation, useMatches } from '@remix-run/react';
+import { startTransition, StrictMode, useEffect } from 'react';
+import { hydrateRoot } from 'react-dom/client';
+import * as Sentry from '@sentry/remix';
+
+Sentry.init({
+  dsn: window.ENV.SENTRY_DSN,
+  integrations: [
+    new Sentry.BrowserTracing({
+      routingInstrumentation: Sentry.remixRouterInstrumentation(useEffect, useLocation, useMatches),
+    }),
+    new Sentry.Replay(),
+  ],
+  // Performance Monitoring
+  tracesSampleRate: 1.0, // Capture 100% of the transactions, reduce in production!
+  // Session Replay
+  replaysSessionSampleRate: 0.1, // This sets the sample rate at 10%. You may want to change it to 100% while in development and then sample at a lower rate in production.
+  replaysOnErrorSampleRate: 1.0, // If you're not already sampling the entire session, change the sample rate to 100% when sampling sessions where errors occur.
+});
+
+Sentry.addGlobalEventProcessor(event => {
+  if (
+    event.type === 'transaction' &&
+    (event.contexts?.trace?.op === 'pageload' || event.contexts?.trace?.op === 'navigation')
+  ) {
+    const eventId = event.event_id;
+    if (eventId) {
+      window.recordedTransactions = window.recordedTransactions || [];
+      window.recordedTransactions.push(eventId);
+    }
+  }
+
+  return event;
+});
+
+startTransition(() => {
+  hydrateRoot(
+    document,
+    <StrictMode>
+      <RemixBrowser />
+    </StrictMode>,
+  );
+});
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/app/entry.server.tsx b/packages/e2e-tests/test-applications/create-remix-app-v2/app/entry.server.tsx
new file mode 100644
index 000000000000..bce3f38ae7f8
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/app/entry.server.tsx
@@ -0,0 +1,133 @@
+/**
+ * By default, Remix will handle generating the HTTP Response for you.
+ * You are free to delete this file if you'd like to, but if you ever want it revealed again, you can run `npx remix reveal` ✨
+ * For more information, see https://remix.run/file-conventions/entry.server
+ */
+
+import { PassThrough } from 'node:stream';
+
+import type { AppLoadContext, EntryContext, DataFunctionArgs } from '@remix-run/node';
+import { createReadableStreamFromReadable } from '@remix-run/node';
+import { RemixServer } from '@remix-run/react';
+import { renderToPipeableStream } from 'react-dom/server';
+import * as Sentry from '@sentry/remix';
+import { installGlobals } from '@remix-run/node';
+import isbot from 'isbot';
+
+installGlobals();
+
+const ABORT_DELAY = 5_000;
+
+Sentry.init({
+  dsn: process.env.E2E_TEST_DSN,
+  // Performance Monitoring
+  tracesSampleRate: 1.0, // Capture 100% of the transactions, reduce in production!
+});
+
+export function handleError(error: unknown, { request }: DataFunctionArgs): void {
+  Sentry.captureRemixServerException(error, 'remix.server', request);
+}
+
+export default function handleRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  remixContext: EntryContext,
+  loadContext: AppLoadContext,
+) {
+  return isbot(request.headers.get('user-agent'))
+    ? handleBotRequest(request, responseStatusCode, responseHeaders, remixContext)
+    : handleBrowserRequest(request, responseStatusCode, responseHeaders, remixContext);
+}
+
+function handleBotRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  remixContext: EntryContext,
+) {
+  return new Promise((resolve, reject) => {
+    let shellRendered = false;
+    const { pipe, abort } = renderToPipeableStream(
+      <RemixServer context={remixContext} url={request.url} abortDelay={ABORT_DELAY} />,
+      {
+        onAllReady() {
+          shellRendered = true;
+          const body = new PassThrough();
+          const stream = createReadableStreamFromReadable(body);
+
+          responseHeaders.set('Content-Type', 'text/html');
+
+          resolve(
+            new Response(stream, {
+              headers: responseHeaders,
+              status: responseStatusCode,
+            }),
+          );
+
+          pipe(body);
+        },
+        onShellError(error: unknown) {
+          reject(error);
+        },
+        onError(error: unknown) {
+          responseStatusCode = 500;
+          // Log streaming rendering errors from inside the shell.  Don't log
+          // errors encountered during initial shell rendering since they'll
+          // reject and get logged in handleDocumentRequest.
+          if (shellRendered) {
+            console.error(error);
+          }
+        },
+      },
+    );
+
+    setTimeout(abort, ABORT_DELAY);
+  });
+}
+
+function handleBrowserRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  remixContext: EntryContext,
+) {
+  return new Promise((resolve, reject) => {
+    let shellRendered = false;
+    const { pipe, abort } = renderToPipeableStream(
+      <RemixServer context={remixContext} url={request.url} abortDelay={ABORT_DELAY} />,
+      {
+        onShellReady() {
+          shellRendered = true;
+          const body = new PassThrough();
+          const stream = createReadableStreamFromReadable(body);
+
+          responseHeaders.set('Content-Type', 'text/html');
+
+          resolve(
+            new Response(stream, {
+              headers: responseHeaders,
+              status: responseStatusCode,
+            }),
+          );
+
+          pipe(body);
+        },
+        onShellError(error: unknown) {
+          reject(error);
+        },
+        onError(error: unknown) {
+          responseStatusCode = 500;
+          // Log streaming rendering errors from inside the shell.  Don't log
+          // errors encountered during initial shell rendering since they'll
+          // reject and get logged in handleDocumentRequest.
+          if (shellRendered) {
+            console.error(error);
+          }
+        },
+      },
+    );
+
+    setTimeout(abort, ABORT_DELAY);
+  });
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/app/root.tsx b/packages/e2e-tests/test-applications/create-remix-app-v2/app/root.tsx
new file mode 100644
index 000000000000..d4b2c07516eb
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/app/root.tsx
@@ -0,0 +1,63 @@
+import { cssBundleHref } from '@remix-run/css-bundle';
+import { json, LinksFunction } from '@remix-run/node';
+import {
+  Links,
+  LiveReload,
+  Meta,
+  Outlet,
+  Scripts,
+  ScrollRestoration,
+  useLoaderData,
+  useRouteError,
+} from '@remix-run/react';
+import { captureRemixErrorBoundaryError, withSentry } from '@sentry/remix';
+
+export const links: LinksFunction = () => [...(cssBundleHref ? [{ rel: 'stylesheet', href: cssBundleHref }] : [])];
+
+export const loader = () => {
+  return json({
+    ENV: {
+      SENTRY_DSN: process.env.E2E_TEST_DSN,
+    },
+  });
+};
+
+export function ErrorBoundary() {
+  const error = useRouteError();
+  const eventId = captureRemixErrorBoundaryError(error);
+
+  return (
+    <div>
+      <span>ErrorBoundary Error</span>
+      <span id="event-id">{eventId}</span>
+    </div>
+  );
+}
+
+function App() {
+  const { ENV } = useLoaderData();
+
+  return (
+    <html lang="en">
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <script
+          dangerouslySetInnerHTML={{
+            __html: `window.ENV = ${JSON.stringify(ENV)}`,
+          }}
+        />
+        <Meta />
+        <Links />
+      </head>
+      <body>
+        <Outlet />
+        <ScrollRestoration />
+        <Scripts />
+        <LiveReload />
+      </body>
+    </html>
+  );
+}
+
+export default withSentry(App);
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/_index.tsx b/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/_index.tsx
new file mode 100644
index 000000000000..c3fcc989f49b
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/_index.tsx
@@ -0,0 +1,21 @@
+import * as Sentry from '@sentry/remix';
+import { Link } from '@remix-run/react';
+
+export default function Index() {
+  return (
+    <div>
+      <input
+        type="button"
+        value="Capture Exception"
+        id="exception-button"
+        onClick={() => {
+          const eventId = Sentry.captureException(new Error('I am an error!'));
+          window.capturedExceptionId = eventId;
+        }}
+      />
+      <Link to="/user/5" id="navigation">
+        navigate
+      </Link>
+    </div>
+  );
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/client-error.tsx b/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/client-error.tsx
new file mode 100644
index 000000000000..4e5330621191
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/client-error.tsx
@@ -0,0 +1,13 @@
+import { useState } from 'react';
+
+export default function ErrorBoundaryCapture() {
+  const [count, setCount] = useState(0);
+
+  if (count > 0) {
+    throw new Error('Sentry React Component Error');
+  } else {
+    setTimeout(() => setCount(count + 1), 0);
+  }
+
+  return <div>{count}</div>;
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/navigate.tsx b/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/navigate.tsx
new file mode 100644
index 000000000000..c7dcea798501
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/navigate.tsx
@@ -0,0 +1,20 @@
+import { LoaderFunction } from '@remix-run/node';
+import { useLoaderData } from '@remix-run/react';
+
+export const loader: LoaderFunction = async ({ params: { id } }) => {
+  if (id === '-1') {
+    throw new Error('Unexpected Server Error');
+  }
+
+  return null;
+};
+
+export default function LoaderError() {
+  const data = useLoaderData();
+
+  return (
+    <div>
+      <h1>{data && data.test ? data.test : 'Not Found'}</h1>
+    </div>
+  );
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/user.$id.tsx b/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/user.$id.tsx
new file mode 100644
index 000000000000..13b2e0a34d1e
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/app/routes/user.$id.tsx
@@ -0,0 +1,3 @@
+export default function User() {
+  return <div>I am a blank page</div>;
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/globals.d.ts b/packages/e2e-tests/test-applications/create-remix-app-v2/globals.d.ts
new file mode 100644
index 000000000000..4130ac6a8a09
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/globals.d.ts
@@ -0,0 +1,7 @@
+interface Window {
+  recordedTransactions?: string[];
+  capturedExceptionId?: string;
+  ENV: {
+    SENTRY_DSN: string;
+  };
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/package.json b/packages/e2e-tests/test-applications/create-remix-app-v2/package.json
new file mode 100644
index 000000000000..ba13c42c5ece
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/package.json
@@ -0,0 +1,35 @@
+{
+  "private": true,
+  "sideEffects": false,
+  "scripts": {
+    "build": "remix build",
+    "dev": "remix dev",
+    "start": "remix-serve build/index.js",
+    "typecheck": "tsc",
+    "clean": "npx rimraf node_modules,pnpm-lock.yaml",
+    "test:build": "pnpm install && npx playwright install && pnpm build",
+    "test:assert": "pnpm playwright test"
+  },
+  "dependencies": {
+    "@sentry/remix": "latest || *",
+    "@remix-run/css-bundle": "2.0.0",
+    "@remix-run/node": "2.0.0",
+    "@remix-run/react": "2.0.0",
+    "@remix-run/serve": "2.0.0",
+    "isbot": "^3.6.8",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.36.2",
+    "@remix-run/dev": "2.0.0",
+    "@remix-run/eslint-config": "2.0.0",
+    "@types/react": "^18.0.35",
+    "@types/react-dom": "^18.0.11",
+    "eslint": "^8.38.0",
+    "typescript": "^5.0.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/playwright.config.ts b/packages/e2e-tests/test-applications/create-remix-app-v2/playwright.config.ts
new file mode 100644
index 000000000000..33f00235771b
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/playwright.config.ts
@@ -0,0 +1,57 @@
+import type { PlaywrightTestConfig } from '@playwright/test';
+import { devices } from '@playwright/test';
+
+const port = 3030;
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+const config: PlaywrightTestConfig = {
+  testDir: './tests',
+  /* Maximum time one test can run for. */
+  timeout: 60 * 1000,
+  expect: {
+    /**
+     * Maximum time expect() should wait for the condition to be met.
+     * For example in `await expect(locator).toHaveText();`
+     */
+    timeout: 5000,
+  },
+  /* Run tests in files in parallel */
+  fullyParallel: true,
+  /* Fail the build on CI if you accidentally left test.only in the source code. */
+  forbidOnly: !!process.env.CI,
+  /* Retry on CI only */
+  retries: 0,
+  /* Opt out of parallel tests on CI. */
+  workers: 1,
+  /* Reporter to use. See https://playwright.dev/docs/test-reporters */
+  reporter: 'list',
+  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+  use: {
+    /* Maximum time each action such as `click()` can take. Defaults to 0 (no limit). */
+    actionTimeout: 0,
+
+    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+    trace: 'on-first-retry',
+  },
+
+  /* Configure projects for major browsers */
+  projects: [
+    {
+      name: 'chromium',
+      use: {
+        ...devices['Desktop Chrome'],
+      },
+    },
+    // For now we only test Chrome!
+  ],
+
+  /* Run your local dev server before starting the tests */
+  webServer: {
+    command: `PORT=${port} pnpm start`,
+    port,
+  },
+};
+
+export default config;
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/remix.config.js b/packages/e2e-tests/test-applications/create-remix-app-v2/remix.config.js
new file mode 100644
index 000000000000..cb3c8c7a9fb7
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/remix.config.js
@@ -0,0 +1,9 @@
+/** @type {import('@remix-run/dev').AppConfig} */
+module.exports = {
+  ignoredRouteFiles: ['**/.*'],
+  // appDirectory: 'app',
+  // assetsBuildDirectory: 'public/build',
+  // serverBuildPath: 'build/index.js',
+  // publicPath: '/build/',
+  serverModuleFormat: 'cjs',
+};
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/remix.env.d.ts b/packages/e2e-tests/test-applications/create-remix-app-v2/remix.env.d.ts
new file mode 100644
index 000000000000..dcf8c45e1d4c
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/remix.env.d.ts
@@ -0,0 +1,2 @@
+/// <reference types="@remix-run/dev" />
+/// <reference types="@remix-run/node" />
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/tests/behaviour-client.test.ts b/packages/e2e-tests/test-applications/create-remix-app-v2/tests/behaviour-client.test.ts
new file mode 100644
index 000000000000..e07481075f5a
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/tests/behaviour-client.test.ts
@@ -0,0 +1,208 @@
+import { test, expect } from '@playwright/test';
+import axios, { AxiosError } from 'axios';
+
+const EVENT_POLLING_TIMEOUT = 30_000;
+
+const authToken = process.env.E2E_TEST_AUTH_TOKEN;
+const sentryTestOrgSlug = process.env.E2E_TEST_SENTRY_ORG_SLUG;
+const sentryTestProject = process.env.E2E_TEST_SENTRY_TEST_PROJECT;
+
+test('Sends a client-side exception to Sentry', async ({ page }) => {
+  await page.goto('/');
+
+  const exceptionButton = page.locator('id=exception-button');
+  await exceptionButton.click();
+
+  const exceptionIdHandle = await page.waitForFunction(() => window.capturedExceptionId);
+  const exceptionEventId = await exceptionIdHandle.jsonValue();
+
+  console.log(`Polling for error eventId: ${exceptionEventId}`);
+
+  await expect
+    .poll(
+      async () => {
+        try {
+          const response = await axios.get(
+            `https://sentry.io/api/0/projects/${sentryTestOrgSlug}/${sentryTestProject}/events/${exceptionEventId}/`,
+            { headers: { Authorization: `Bearer ${authToken}` } },
+          );
+
+          return response.status;
+        } catch (e) {
+          if (e instanceof AxiosError && e.response) {
+            if (e.response.status !== 404) {
+              throw e;
+            } else {
+              return e.response.status;
+            }
+          } else {
+            throw e;
+          }
+        }
+      },
+      {
+        timeout: EVENT_POLLING_TIMEOUT,
+      },
+    )
+    .toBe(200);
+});
+
+test('Sends a pageload transaction to Sentry', async ({ page }) => {
+  await page.goto('/');
+
+  const recordedTransactionsHandle = await page.waitForFunction(() => {
+    if (window.recordedTransactions && window.recordedTransactions?.length >= 1) {
+      return window.recordedTransactions;
+    } else {
+      return undefined;
+    }
+  });
+  const recordedTransactionEventIds = await recordedTransactionsHandle.jsonValue();
+
+  if (recordedTransactionEventIds === undefined) {
+    throw new Error("Application didn't record any transaction event IDs.");
+  }
+
+  let hadPageLoadTransaction = false;
+
+  console.log(`Polling for transaction eventIds: ${JSON.stringify(recordedTransactionEventIds)}`);
+
+  await Promise.all(
+    recordedTransactionEventIds.map(async transactionEventId => {
+      await expect
+        .poll(
+          async () => {
+            try {
+              const response = await axios.get(
+                `https://sentry.io/api/0/projects/${sentryTestOrgSlug}/${sentryTestProject}/events/${transactionEventId}/`,
+                { headers: { Authorization: `Bearer ${authToken}` } },
+              );
+
+              if (response.data.contexts.trace.op === 'pageload') {
+                hadPageLoadTransaction = true;
+              }
+
+              return response.status;
+            } catch (e) {
+              if (e instanceof AxiosError && e.response) {
+                if (e.response.status !== 404) {
+                  throw e;
+                } else {
+                  return e.response.status;
+                }
+              } else {
+                throw e;
+              }
+            }
+          },
+          {
+            timeout: EVENT_POLLING_TIMEOUT,
+          },
+        )
+        .toBe(200);
+    }),
+  );
+
+  expect(hadPageLoadTransaction).toBe(true);
+});
+
+test('Sends a navigation transaction to Sentry', async ({ page }) => {
+  await page.goto('/');
+
+  // Give pageload transaction time to finish
+  await page.waitForTimeout(4000);
+
+  const linkElement = page.locator('id=navigation');
+  await linkElement.click();
+
+  const recordedTransactionsHandle = await page.waitForFunction(() => {
+    if (window.recordedTransactions && window.recordedTransactions?.length >= 2) {
+      return window.recordedTransactions;
+    } else {
+      return undefined;
+    }
+  });
+  const recordedTransactionEventIds = await recordedTransactionsHandle.jsonValue();
+
+  if (recordedTransactionEventIds === undefined) {
+    throw new Error("Application didn't record any transaction event IDs.");
+  }
+
+  let hadPageNavigationTransaction = false;
+
+  console.log(`Polling for transaction eventIds: ${JSON.stringify(recordedTransactionEventIds)}`);
+
+  await Promise.all(
+    recordedTransactionEventIds.map(async transactionEventId => {
+      await expect
+        .poll(
+          async () => {
+            try {
+              const response = await axios.get(
+                `https://sentry.io/api/0/projects/${sentryTestOrgSlug}/${sentryTestProject}/events/${transactionEventId}/`,
+                { headers: { Authorization: `Bearer ${authToken}` } },
+              );
+
+              if (response.data.contexts.trace.op === 'navigation') {
+                hadPageNavigationTransaction = true;
+              }
+
+              return response.status;
+            } catch (e) {
+              if (e instanceof AxiosError && e.response) {
+                if (e.response.status !== 404) {
+                  throw e;
+                } else {
+                  return e.response.status;
+                }
+              } else {
+                throw e;
+              }
+            }
+          },
+          {
+            timeout: EVENT_POLLING_TIMEOUT,
+          },
+        )
+        .toBe(200);
+    }),
+  );
+
+  expect(hadPageNavigationTransaction).toBe(true);
+});
+
+test('Sends a client-side ErrorBoundary exception to Sentry', async ({ page }) => {
+  await page.goto('/client-error');
+
+  const exceptionIdHandle = await page.waitForSelector('#event-id');
+  const exceptionEventId = await exceptionIdHandle.textContent();
+
+  console.log(`Polling for error eventId: ${exceptionEventId}`);
+
+  await expect
+    .poll(
+      async () => {
+        try {
+          const response = await axios.get(
+            `https://sentry.io/api/0/projects/${sentryTestOrgSlug}/${sentryTestProject}/events/${exceptionEventId}/`,
+            { headers: { Authorization: `Bearer ${authToken}` } },
+          );
+          return response.status;
+        } catch (e) {
+          if (e instanceof AxiosError && e.response) {
+            if (e.response.status !== 404) {
+              throw e;
+            } else {
+              return e.response.status;
+            }
+          } else {
+            throw e;
+          }
+        }
+      },
+      {
+        timeout: EVENT_POLLING_TIMEOUT,
+      },
+    )
+    .toBe(200);
+});
diff --git a/packages/e2e-tests/test-applications/create-remix-app-v2/tsconfig.json b/packages/e2e-tests/test-applications/create-remix-app-v2/tsconfig.json
new file mode 100644
index 000000000000..20f8a386a6c4
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app-v2/tsconfig.json
@@ -0,0 +1,22 @@
+{
+  "include": ["remix.env.d.ts", "**/*.ts", "**/*.tsx"],
+  "compilerOptions": {
+    "lib": ["DOM", "DOM.Iterable", "ES2019"],
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "jsx": "react-jsx",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "target": "ES2019",
+    "strict": true,
+    "allowJs": true,
+    "forceConsistentCasingInFileNames": true,
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["./app/*"]
+    },
+
+    // Remix takes care of building everything in `remix build`.
+    "noEmit": true
+  }
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app/app/entry.client.tsx b/packages/e2e-tests/test-applications/create-remix-app/app/entry.client.tsx
index a4d1618fd976..605d8e792d23 100644
--- a/packages/e2e-tests/test-applications/create-remix-app/app/entry.client.tsx
+++ b/packages/e2e-tests/test-applications/create-remix-app/app/entry.client.tsx
@@ -10,7 +10,7 @@ import { hydrateRoot } from 'react-dom/client';
 import * as Sentry from '@sentry/remix';
 
 Sentry.init({
-  dsn: process.env.E2E_TEST_DSN,
+  dsn: window.ENV.SENTRY_DSN,
   integrations: [
     new Sentry.BrowserTracing({
       routingInstrumentation: Sentry.remixRouterInstrumentation(useEffect, useLocation, useMatches),
@@ -24,6 +24,21 @@ Sentry.init({
   replaysOnErrorSampleRate: 1.0, // If you're not already sampling the entire session, change the sample rate to 100% when sampling sessions where errors occur.
 });
 
+Sentry.addGlobalEventProcessor(event => {
+  if (
+    event.type === 'transaction' &&
+    (event.contexts?.trace?.op === 'pageload' || event.contexts?.trace?.op === 'navigation')
+  ) {
+    const eventId = event.event_id;
+    if (eventId) {
+      window.recordedTransactions = window.recordedTransactions || [];
+      window.recordedTransactions.push(eventId);
+    }
+  }
+
+  return event;
+});
+
 startTransition(() => {
   hydrateRoot(
     document,
diff --git a/packages/e2e-tests/test-applications/create-remix-app/app/entry.server.tsx b/packages/e2e-tests/test-applications/create-remix-app/app/entry.server.tsx
index 62dd7ea43df2..d8679d2074b1 100644
--- a/packages/e2e-tests/test-applications/create-remix-app/app/entry.server.tsx
+++ b/packages/e2e-tests/test-applications/create-remix-app/app/entry.server.tsx
@@ -6,7 +6,7 @@
 
 import { PassThrough } from 'node:stream';
 
-import type { AppLoadContext, EntryContext } from '@remix-run/node';
+import type { AppLoadContext, EntryContext, DataFunctionArgs } from '@remix-run/node';
 import { Response } from '@remix-run/node';
 import { RemixServer } from '@remix-run/react';
 import isbot from 'isbot';
@@ -21,6 +21,10 @@ Sentry.init({
   tracesSampleRate: 1.0, // Capture 100% of the transactions, reduce in production!
 });
 
+export function handleError(error: unknown, { request }: DataFunctionArgs): void {
+  Sentry.captureRemixServerException(error, 'remix.server', request);
+}
+
 export default function handleRequest(
   request: Request,
   responseStatusCode: number,
diff --git a/packages/e2e-tests/test-applications/create-remix-app/app/root.tsx b/packages/e2e-tests/test-applications/create-remix-app/app/root.tsx
index 0f3d1a16e8a8..d4b2c07516eb 100644
--- a/packages/e2e-tests/test-applications/create-remix-app/app/root.tsx
+++ b/packages/e2e-tests/test-applications/create-remix-app/app/root.tsx
@@ -1,16 +1,52 @@
 import { cssBundleHref } from '@remix-run/css-bundle';
-import type { LinksFunction } from '@remix-run/node';
-import { Links, LiveReload, Meta, Outlet, Scripts, ScrollRestoration } from '@remix-run/react';
-import { withSentry } from '@sentry/remix';
+import { json, LinksFunction } from '@remix-run/node';
+import {
+  Links,
+  LiveReload,
+  Meta,
+  Outlet,
+  Scripts,
+  ScrollRestoration,
+  useLoaderData,
+  useRouteError,
+} from '@remix-run/react';
+import { captureRemixErrorBoundaryError, withSentry } from '@sentry/remix';
 
 export const links: LinksFunction = () => [...(cssBundleHref ? [{ rel: 'stylesheet', href: cssBundleHref }] : [])];
 
+export const loader = () => {
+  return json({
+    ENV: {
+      SENTRY_DSN: process.env.E2E_TEST_DSN,
+    },
+  });
+};
+
+export function ErrorBoundary() {
+  const error = useRouteError();
+  const eventId = captureRemixErrorBoundaryError(error);
+
+  return (
+    <div>
+      <span>ErrorBoundary Error</span>
+      <span id="event-id">{eventId}</span>
+    </div>
+  );
+}
+
 function App() {
+  const { ENV } = useLoaderData();
+
   return (
     <html lang="en">
       <head>
         <meta charSet="utf-8" />
         <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <script
+          dangerouslySetInnerHTML={{
+            __html: `window.ENV = ${JSON.stringify(ENV)}`,
+          }}
+        />
         <Meta />
         <Links />
       </head>
diff --git a/packages/e2e-tests/test-applications/create-remix-app/app/routes/_index.tsx b/packages/e2e-tests/test-applications/create-remix-app/app/routes/_index.tsx
index e279d69b17b3..c3fcc989f49b 100644
--- a/packages/e2e-tests/test-applications/create-remix-app/app/routes/_index.tsx
+++ b/packages/e2e-tests/test-applications/create-remix-app/app/routes/_index.tsx
@@ -1,30 +1,21 @@
-import type { V2_MetaFunction } from '@remix-run/node';
-
-export const meta: V2_MetaFunction = () => {
-  return [{ title: 'New Remix App' }, { name: 'description', content: 'Welcome to Remix!' }];
-};
+import * as Sentry from '@sentry/remix';
+import { Link } from '@remix-run/react';
 
 export default function Index() {
   return (
-    <div style={{ fontFamily: 'system-ui, sans-serif', lineHeight: '1.8' }}>
-      <h1>Welcome to Remix</h1>
-      <ul>
-        <li>
-          <a target="_blank" href="https://remix.run/tutorials/blog" rel="noreferrer">
-            15m Quickstart Blog Tutorial
-          </a>
-        </li>
-        <li>
-          <a target="_blank" href="https://remix.run/tutorials/jokes" rel="noreferrer">
-            Deep Dive Jokes App Tutorial
-          </a>
-        </li>
-        <li>
-          <a target="_blank" href="https://remix.run/docs" rel="noreferrer">
-            Remix Docs
-          </a>
-        </li>
-      </ul>
+    <div>
+      <input
+        type="button"
+        value="Capture Exception"
+        id="exception-button"
+        onClick={() => {
+          const eventId = Sentry.captureException(new Error('I am an error!'));
+          window.capturedExceptionId = eventId;
+        }}
+      />
+      <Link to="/user/5" id="navigation">
+        navigate
+      </Link>
     </div>
   );
 }
diff --git a/packages/e2e-tests/test-applications/create-remix-app/app/routes/client-error.tsx b/packages/e2e-tests/test-applications/create-remix-app/app/routes/client-error.tsx
new file mode 100644
index 000000000000..4e5330621191
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app/app/routes/client-error.tsx
@@ -0,0 +1,13 @@
+import { useState } from 'react';
+
+export default function ErrorBoundaryCapture() {
+  const [count, setCount] = useState(0);
+
+  if (count > 0) {
+    throw new Error('Sentry React Component Error');
+  } else {
+    setTimeout(() => setCount(count + 1), 0);
+  }
+
+  return <div>{count}</div>;
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app/app/routes/navigate.tsx b/packages/e2e-tests/test-applications/create-remix-app/app/routes/navigate.tsx
new file mode 100644
index 000000000000..c7dcea798501
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app/app/routes/navigate.tsx
@@ -0,0 +1,20 @@
+import { LoaderFunction } from '@remix-run/node';
+import { useLoaderData } from '@remix-run/react';
+
+export const loader: LoaderFunction = async ({ params: { id } }) => {
+  if (id === '-1') {
+    throw new Error('Unexpected Server Error');
+  }
+
+  return null;
+};
+
+export default function LoaderError() {
+  const data = useLoaderData();
+
+  return (
+    <div>
+      <h1>{data && data.test ? data.test : 'Not Found'}</h1>
+    </div>
+  );
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app/app/routes/user.$id.tsx b/packages/e2e-tests/test-applications/create-remix-app/app/routes/user.$id.tsx
new file mode 100644
index 000000000000..13b2e0a34d1e
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app/app/routes/user.$id.tsx
@@ -0,0 +1,3 @@
+export default function User() {
+  return <div>I am a blank page</div>;
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app/globals.d.ts b/packages/e2e-tests/test-applications/create-remix-app/globals.d.ts
new file mode 100644
index 000000000000..4130ac6a8a09
--- /dev/null
+++ b/packages/e2e-tests/test-applications/create-remix-app/globals.d.ts
@@ -0,0 +1,7 @@
+interface Window {
+  recordedTransactions?: string[];
+  capturedExceptionId?: string;
+  ENV: {
+    SENTRY_DSN: string;
+  };
+}
diff --git a/packages/e2e-tests/test-applications/create-remix-app/package.json b/packages/e2e-tests/test-applications/create-remix-app/package.json
index 0927785fc50d..dbcf72c676d0 100644
--- a/packages/e2e-tests/test-applications/create-remix-app/package.json
+++ b/packages/e2e-tests/test-applications/create-remix-app/package.json
@@ -12,18 +12,18 @@
   },
   "dependencies": {
     "@sentry/remix": "latest || *",
-    "@remix-run/css-bundle": "^1.16.1",
-    "@remix-run/node": "^1.16.1",
-    "@remix-run/react": "^1.16.1",
-    "@remix-run/serve": "^1.16.1",
+    "@remix-run/css-bundle": "^1.19.3",
+    "@remix-run/node": "^1.19.3",
+    "@remix-run/react": "^1.19.3",
+    "@remix-run/serve": "^1.19.3",
     "isbot": "^3.6.8",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.36.2",
-    "@remix-run/dev": "^1.16.1",
-    "@remix-run/eslint-config": "^1.16.1",
+    "@remix-run/dev": "^1.19.3",
+    "@remix-run/eslint-config": "^1.19.3",
     "@types/react": "^18.0.35",
     "@types/react-dom": "^18.0.11",
     "eslint": "^8.38.0",
diff --git a/packages/e2e-tests/test-applications/create-remix-app/remix.config.js b/packages/e2e-tests/test-applications/create-remix-app/remix.config.js
index 1203199a8d5f..1cab174f72fe 100644
--- a/packages/e2e-tests/test-applications/create-remix-app/remix.config.js
+++ b/packages/e2e-tests/test-applications/create-remix-app/remix.config.js
@@ -7,6 +7,8 @@ module.exports = {
   // publicPath: "/build/",
   serverModuleFormat: 'cjs',
   future: {
+    v2_dev: true,
+    v2_headers: true,
     v2_errorBoundary: true,
     v2_meta: true,
     v2_normalizeFormMethod: true,
diff --git a/packages/e2e-tests/test-applications/create-remix-app/tests/behaviour-client.test.ts b/packages/e2e-tests/test-applications/create-remix-app/tests/behaviour-client.test.ts
index 9b5861619bec..e07481075f5a 100644
--- a/packages/e2e-tests/test-applications/create-remix-app/tests/behaviour-client.test.ts
+++ b/packages/e2e-tests/test-applications/create-remix-app/tests/behaviour-client.test.ts
@@ -1,7 +1,208 @@
 import { test, expect } from '@playwright/test';
+import axios, { AxiosError } from 'axios';
 
-test('Boots up correctly', async ({ page }) => {
+const EVENT_POLLING_TIMEOUT = 30_000;
+
+const authToken = process.env.E2E_TEST_AUTH_TOKEN;
+const sentryTestOrgSlug = process.env.E2E_TEST_SENTRY_ORG_SLUG;
+const sentryTestProject = process.env.E2E_TEST_SENTRY_TEST_PROJECT;
+
+test('Sends a client-side exception to Sentry', async ({ page }) => {
+  await page.goto('/');
+
+  const exceptionButton = page.locator('id=exception-button');
+  await exceptionButton.click();
+
+  const exceptionIdHandle = await page.waitForFunction(() => window.capturedExceptionId);
+  const exceptionEventId = await exceptionIdHandle.jsonValue();
+
+  console.log(`Polling for error eventId: ${exceptionEventId}`);
+
+  await expect
+    .poll(
+      async () => {
+        try {
+          const response = await axios.get(
+            `https://sentry.io/api/0/projects/${sentryTestOrgSlug}/${sentryTestProject}/events/${exceptionEventId}/`,
+            { headers: { Authorization: `Bearer ${authToken}` } },
+          );
+
+          return response.status;
+        } catch (e) {
+          if (e instanceof AxiosError && e.response) {
+            if (e.response.status !== 404) {
+              throw e;
+            } else {
+              return e.response.status;
+            }
+          } else {
+            throw e;
+          }
+        }
+      },
+      {
+        timeout: EVENT_POLLING_TIMEOUT,
+      },
+    )
+    .toBe(200);
+});
+
+test('Sends a pageload transaction to Sentry', async ({ page }) => {
   await page.goto('/');
 
-  await expect(page.getByRole('heading')).toHaveText('Welcome to Remix');
+  const recordedTransactionsHandle = await page.waitForFunction(() => {
+    if (window.recordedTransactions && window.recordedTransactions?.length >= 1) {
+      return window.recordedTransactions;
+    } else {
+      return undefined;
+    }
+  });
+  const recordedTransactionEventIds = await recordedTransactionsHandle.jsonValue();
+
+  if (recordedTransactionEventIds === undefined) {
+    throw new Error("Application didn't record any transaction event IDs.");
+  }
+
+  let hadPageLoadTransaction = false;
+
+  console.log(`Polling for transaction eventIds: ${JSON.stringify(recordedTransactionEventIds)}`);
+
+  await Promise.all(
+    recordedTransactionEventIds.map(async transactionEventId => {
+      await expect
+        .poll(
+          async () => {
+            try {
+              const response = await axios.get(
+                `https://sentry.io/api/0/projects/${sentryTestOrgSlug}/${sentryTestProject}/events/${transactionEventId}/`,
+                { headers: { Authorization: `Bearer ${authToken}` } },
+              );
+
+              if (response.data.contexts.trace.op === 'pageload') {
+                hadPageLoadTransaction = true;
+              }
+
+              return response.status;
+            } catch (e) {
+              if (e instanceof AxiosError && e.response) {
+                if (e.response.status !== 404) {
+                  throw e;
+                } else {
+                  return e.response.status;
+                }
+              } else {
+                throw e;
+              }
+            }
+          },
+          {
+            timeout: EVENT_POLLING_TIMEOUT,
+          },
+        )
+        .toBe(200);
+    }),
+  );
+
+  expect(hadPageLoadTransaction).toBe(true);
+});
+
+test('Sends a navigation transaction to Sentry', async ({ page }) => {
+  await page.goto('/');
+
+  // Give pageload transaction time to finish
+  await page.waitForTimeout(4000);
+
+  const linkElement = page.locator('id=navigation');
+  await linkElement.click();
+
+  const recordedTransactionsHandle = await page.waitForFunction(() => {
+    if (window.recordedTransactions && window.recordedTransactions?.length >= 2) {
+      return window.recordedTransactions;
+    } else {
+      return undefined;
+    }
+  });
+  const recordedTransactionEventIds = await recordedTransactionsHandle.jsonValue();
+
+  if (recordedTransactionEventIds === undefined) {
+    throw new Error("Application didn't record any transaction event IDs.");
+  }
+
+  let hadPageNavigationTransaction = false;
+
+  console.log(`Polling for transaction eventIds: ${JSON.stringify(recordedTransactionEventIds)}`);
+
+  await Promise.all(
+    recordedTransactionEventIds.map(async transactionEventId => {
+      await expect
+        .poll(
+          async () => {
+            try {
+              const response = await axios.get(
+                `https://sentry.io/api/0/projects/${sentryTestOrgSlug}/${sentryTestProject}/events/${transactionEventId}/`,
+                { headers: { Authorization: `Bearer ${authToken}` } },
+              );
+
+              if (response.data.contexts.trace.op === 'navigation') {
+                hadPageNavigationTransaction = true;
+              }
+
+              return response.status;
+            } catch (e) {
+              if (e instanceof AxiosError && e.response) {
+                if (e.response.status !== 404) {
+                  throw e;
+                } else {
+                  return e.response.status;
+                }
+              } else {
+                throw e;
+              }
+            }
+          },
+          {
+            timeout: EVENT_POLLING_TIMEOUT,
+          },
+        )
+        .toBe(200);
+    }),
+  );
+
+  expect(hadPageNavigationTransaction).toBe(true);
+});
+
+test('Sends a client-side ErrorBoundary exception to Sentry', async ({ page }) => {
+  await page.goto('/client-error');
+
+  const exceptionIdHandle = await page.waitForSelector('#event-id');
+  const exceptionEventId = await exceptionIdHandle.textContent();
+
+  console.log(`Polling for error eventId: ${exceptionEventId}`);
+
+  await expect
+    .poll(
+      async () => {
+        try {
+          const response = await axios.get(
+            `https://sentry.io/api/0/projects/${sentryTestOrgSlug}/${sentryTestProject}/events/${exceptionEventId}/`,
+            { headers: { Authorization: `Bearer ${authToken}` } },
+          );
+          return response.status;
+        } catch (e) {
+          if (e instanceof AxiosError && e.response) {
+            if (e.response.status !== 404) {
+              throw e;
+            } else {
+              return e.response.status;
+            }
+          } else {
+            throw e;
+          }
+        }
+      },
+      {
+        timeout: EVENT_POLLING_TIMEOUT,
+      },
+    )
+    .toBe(200);
 });
diff --git a/packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/edge/route.ts b/packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/edge/route.ts
index a43862231568..8c96a39e5554 100644
--- a/packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/edge/route.ts
+++ b/packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/edge/route.ts
@@ -6,6 +6,6 @@ export async function PATCH() {
   return NextResponse.json({ name: 'John Doe' }, { status: 401 });
 }
 
-export async function DELETE(): Promise<Response> {
+export async function DELETE() {
   throw new Error('route-handler-edge-error');
 }
diff --git a/packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/error/route.ts b/packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/error/route.ts
index e2de561c4783..fd50ef5c8a44 100644
--- a/packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/error/route.ts
+++ b/packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/error/route.ts
@@ -1,3 +1,3 @@
-export async function PUT(): Promise<Response> {
+export async function PUT() {
   throw new Error('route-handler-error');
 }
diff --git a/packages/remix/package.json b/packages/remix/package.json
index f1180e7e8925..6d669ff2672c 100644
--- a/packages/remix/package.json
+++ b/packages/remix/package.json
@@ -43,8 +43,8 @@
     "@types/express": "^4.17.14"
   },
   "peerDependencies": {
-    "@remix-run/node": "1.x",
-    "@remix-run/react": "1.x",
+    "@remix-run/node": "1.x || 2.x",
+    "@remix-run/react": "1.x || 2.x",
     "react": "16.x || 17.x || 18.x"
   },
   "scripts": {
diff --git a/packages/remix/src/client/errors.tsx b/packages/remix/src/client/errors.tsx
index ec2bf44a79e1..6732ed5cdc91 100644
--- a/packages/remix/src/client/errors.tsx
+++ b/packages/remix/src/client/errors.tsx
@@ -1,19 +1,7 @@
 import { captureException, withScope } from '@sentry/core';
 import { addExceptionMechanism, isNodeEnv, isString } from '@sentry/utils';
 
-import type { ErrorResponse } from '../utils/vendor/types';
-
-/**
- * Checks whether the given error is an ErrorResponse.
- * ErrorResponse is when users throw a response from their loader or action functions.
- * This is in fact a server-side error that we capture on the client.
- *
- * @param error The error to check.
- * @returns boolean
- */
-function isErrorResponse(error: unknown): error is ErrorResponse {
-  return typeof error === 'object' && error !== null && 'status' in error && 'statusText' in error;
-}
+import { isRouteErrorResponse } from '../utils/vendor/response';
 
 /**
  * Captures an error that is thrown inside a Remix ErrorBoundary.
@@ -21,14 +9,15 @@ function isErrorResponse(error: unknown): error is ErrorResponse {
  * @param error The error to capture.
  * @returns void
  */
-export function captureRemixErrorBoundaryError(error: unknown): void {
+export function captureRemixErrorBoundaryError(error: unknown): string | undefined {
+  let eventId: string | undefined;
   const isClientSideRuntimeError = !isNodeEnv() && error instanceof Error;
-  const isRemixErrorResponse = isErrorResponse(error);
+  const isRemixErrorResponse = isRouteErrorResponse(error);
   // Server-side errors apart from `ErrorResponse`s also appear here without their stacktraces.
   // So, we only capture:
   //    1. `ErrorResponse`s
   //    2. Client-side runtime errors here,
-  //    And other server - side errors in `handleError` function where stacktraces are available.
+  //    And other server-side errors captured in `handleError` function where stacktraces are available.
   if (isRemixErrorResponse || isClientSideRuntimeError) {
     const eventData = isRemixErrorResponse
       ? {
@@ -51,15 +40,17 @@ export function captureRemixErrorBoundaryError(error: unknown): void {
 
       if (isRemixErrorResponse) {
         if (isString(error.data)) {
-          captureException(error.data);
+          eventId = captureException(error.data);
         } else if (error.statusText) {
-          captureException(error.statusText);
+          eventId = captureException(error.statusText);
         } else {
-          captureException(error);
+          eventId = captureException(error);
         }
       } else {
-        captureException(error);
+        eventId = captureException(error);
       }
     });
   }
+
+  return eventId;
 }
diff --git a/packages/remix/src/client/performance.tsx b/packages/remix/src/client/performance.tsx
index f47d11760556..427bfb9c5dfd 100644
--- a/packages/remix/src/client/performance.tsx
+++ b/packages/remix/src/client/performance.tsx
@@ -4,7 +4,7 @@ import type { Transaction, TransactionContext } from '@sentry/types';
 import { isNodeEnv, logger } from '@sentry/utils';
 import * as React from 'react';
 
-import { getFutureFlagsBrowser } from '../utils/futureFlags';
+import { getFutureFlagsBrowser, readRemixVersionFromLoader } from '../utils/futureFlags';
 
 const DEFAULT_TAGS = {
   'routing.instrumentation': 'remix-router',
@@ -48,6 +48,10 @@ function getInitPathName(): string | undefined {
   return undefined;
 }
 
+function isRemixV2(remixVersion: number | undefined): boolean {
+  return remixVersion === 2 || getFutureFlagsBrowser()?.v2_errorBoundary || false;
+}
+
 /**
  * Creates a react-router v6 instrumention for Remix applications.
  *
@@ -97,7 +101,7 @@ export function withSentry<P extends Record<string, unknown>, R extends React.FC
     errorBoundaryOptions?: ErrorBoundaryProps;
   } = {
     // We don't want to wrap application with Sentry's ErrorBoundary by default for Remix v2
-    wrapWithErrorBoundary: getFutureFlagsBrowser()?.v2_errorBoundary ? false : true,
+    wrapWithErrorBoundary: true,
     errorBoundaryOptions: {},
   },
 ): R {
@@ -154,17 +158,16 @@ export function withSentry<P extends Record<string, unknown>, R extends React.FC
 
     isBaseLocation = false;
 
+    if (!isRemixV2(readRemixVersionFromLoader()) && options.wrapWithErrorBoundary) {
+      // @ts-expect-error Setting more specific React Component typing for `R` generic above
+      // will break advanced type inference done by react router params
+      return withErrorBoundary(OrigApp, options.errorBoundaryOptions)(props);
+    }
     // @ts-expect-error Setting more specific React Component typing for `R` generic above
     // will break advanced type inference done by react router params
     return <OrigApp {...props} />;
   };
 
-  if (options.wrapWithErrorBoundary) {
-    // @ts-expect-error Setting more specific React Component typing for `R` generic above
-    // will break advanced type inference done by react router params
-    return withErrorBoundary(SentryRoot, options.errorBoundaryOptions);
-  }
-
   // @ts-expect-error Setting more specific React Component typing for `R` generic above
   // will break advanced type inference done by react router params
   return SentryRoot;
diff --git a/packages/remix/src/index.server.ts b/packages/remix/src/index.server.ts
index 4c37351001c2..53757b4a89f4 100644
--- a/packages/remix/src/index.server.ts
+++ b/packages/remix/src/index.server.ts
@@ -1,4 +1,5 @@
 /* eslint-disable import/export */
+import type { NodeOptions } from '@sentry/node';
 import { configureScope, getCurrentHub, init as nodeInit } from '@sentry/node';
 import { logger } from '@sentry/utils';
 
@@ -77,7 +78,7 @@ export function init(options: RemixOptions): void {
 
   instrumentServer();
 
-  nodeInit(options);
+  nodeInit(options as NodeOptions);
 
   configureScope(scope => {
     scope.setTag('runtime', 'node');
diff --git a/packages/remix/src/utils/futureFlags.ts b/packages/remix/src/utils/futureFlags.ts
index 7d797c19e8a2..03d03270a73e 100644
--- a/packages/remix/src/utils/futureFlags.ts
+++ b/packages/remix/src/utils/futureFlags.ts
@@ -5,6 +5,13 @@ import type { FutureConfig, ServerBuild } from './vendor/types';
 export type EnhancedGlobal = typeof GLOBAL_OBJ & {
   __remixContext?: {
     future?: FutureConfig;
+    state?: {
+      loaderData?: {
+        root?: {
+          remixVersion?: number;
+        };
+      };
+    };
   };
 };
 
@@ -33,3 +40,28 @@ export function getFutureFlagsBrowser(): FutureConfig | undefined {
 export function getFutureFlagsServer(build: ServerBuild): FutureConfig | undefined {
   return build.future;
 }
+
+/**
+ * Learn Remix version from the server build object
+ * V2 Server builds have a non-optional `mode` property
+ *
+ * @returns The major version number
+ */
+export function getRemixVersionFromBuild(build: ServerBuild): number {
+  if ('mode' in build) {
+    return 2;
+  }
+
+  return 1;
+}
+
+/**
+ * Read Remix version from the Remix context on the browser
+ *
+ * @returns The major version number
+ */
+export function readRemixVersionFromLoader(): number | undefined {
+  const window = GLOBAL_OBJ as EnhancedGlobal;
+
+  return window.__remixContext?.state?.loaderData?.root?.remixVersion;
+}
diff --git a/packages/remix/src/utils/instrumentServer.ts b/packages/remix/src/utils/instrumentServer.ts
index f98bdd6bcd24..a80e795fb9a6 100644
--- a/packages/remix/src/utils/instrumentServer.ts
+++ b/packages/remix/src/utils/instrumentServer.ts
@@ -13,8 +13,16 @@ import {
   tracingContextFromHeaders,
 } from '@sentry/utils';
 
-import { getFutureFlagsServer } from './futureFlags';
-import { extractData, getRequestMatch, isDeferredData, isResponse, json, matchServerRoutes } from './vendor/response';
+import { getFutureFlagsServer, getRemixVersionFromBuild } from './futureFlags';
+import {
+  extractData,
+  getRequestMatch,
+  isDeferredData,
+  isResponse,
+  isRouteErrorResponse,
+  json,
+  matchServerRoutes,
+} from './vendor/response';
 import type {
   AppData,
   CreateRequestHandlerFunction,
@@ -33,6 +41,7 @@ import type {
 import { normalizeRemixRequest } from './web-fetch';
 
 let FUTURE_FLAGS: FutureConfig | undefined;
+let IS_REMIX_V2: boolean | undefined;
 
 // Flag to track if the core request handler is instrumented.
 export let isRequestHandlerWrapped = false;
@@ -72,7 +81,11 @@ async function extractResponseError(response: Response): Promise<unknown> {
 export async function captureRemixServerException(err: unknown, name: string, request: Request): Promise<void> {
   // Skip capturing if the thrown error is not a 5xx response
   // https://remix.run/docs/en/v1/api/conventions#throwing-responses-in-loaders
-  if (isResponse(err) && err.status < 500) {
+  if (IS_REMIX_V2) {
+    if (isRouteErrorResponse(err) && err.status < 500) {
+      return;
+    }
+  } else if (isResponse(err) && err.status < 500) {
     return;
   }
 
@@ -117,55 +130,60 @@ export async function captureRemixServerException(err: unknown, name: string, re
   });
 }
 
-function makeWrappedDocumentRequestFunction(
-  origDocumentRequestFunction: HandleDocumentRequestFunction,
-): HandleDocumentRequestFunction {
-  return async function (
-    this: unknown,
-    request: Request,
-    responseStatusCode: number,
-    responseHeaders: Headers,
-    context: EntryContext,
-    loadContext?: Record<string, unknown>,
-  ): Promise<Response> {
-    let res: Response;
+function makeWrappedDocumentRequestFunction(remixVersion: number) {
+  return function (origDocumentRequestFunction: HandleDocumentRequestFunction): HandleDocumentRequestFunction {
+    return async function (
+      this: unknown,
+      request: Request,
+      responseStatusCode: number,
+      responseHeaders: Headers,
+      context: EntryContext,
+      loadContext?: Record<string, unknown>,
+    ): Promise<Response> {
+      let res: Response;
 
-    const activeTransaction = getActiveTransaction();
-
-    try {
-      const span = activeTransaction?.startChild({
-        op: 'function.remix.document_request',
-        origin: 'auto.function.remix',
-        description: activeTransaction.name,
-        tags: {
-          method: request.method,
-          url: request.url,
-        },
-      });
+      const activeTransaction = getActiveTransaction();
 
-      res = await origDocumentRequestFunction.call(
-        this,
-        request,
-        responseStatusCode,
-        responseHeaders,
-        context,
-        loadContext,
-      );
+      try {
+        const span = activeTransaction?.startChild({
+          op: 'function.remix.document_request',
+          origin: 'auto.function.remix',
+          description: activeTransaction.name,
+          tags: {
+            method: request.method,
+            url: request.url,
+          },
+        });
+
+        res = await origDocumentRequestFunction.call(
+          this,
+          request,
+          responseStatusCode,
+          responseHeaders,
+          context,
+          loadContext,
+        );
+
+        span?.finish();
+      } catch (err) {
+        if (!FUTURE_FLAGS?.v2_errorBoundary && remixVersion !== 2) {
+          await captureRemixServerException(err, 'documentRequest', request);
+        }
 
-      span?.finish();
-    } catch (err) {
-      if (!FUTURE_FLAGS?.v2_errorBoundary) {
-        await captureRemixServerException(err, 'documentRequest', request);
+        throw err;
       }
 
-      throw err;
-    }
-
-    return res;
+      return res;
+    };
   };
 }
 
-function makeWrappedDataFunction(origFn: DataFunction, id: string, name: 'action' | 'loader'): DataFunction {
+function makeWrappedDataFunction(
+  origFn: DataFunction,
+  id: string,
+  name: 'action' | 'loader',
+  remixVersion: number,
+): DataFunction {
   return async function (this: unknown, args: DataFunctionArgs): Promise<Response | AppData> {
     let res: Response | AppData;
     const activeTransaction = getActiveTransaction();
@@ -191,7 +209,7 @@ function makeWrappedDataFunction(origFn: DataFunction, id: string, name: 'action
       currentScope.setSpan(activeTransaction);
       span?.finish();
     } catch (err) {
-      if (!FUTURE_FLAGS?.v2_errorBoundary) {
+      if (!FUTURE_FLAGS?.v2_errorBoundary && remixVersion !== 2) {
         await captureRemixServerException(err, name, args.request);
       }
 
@@ -203,15 +221,15 @@ function makeWrappedDataFunction(origFn: DataFunction, id: string, name: 'action
 }
 
 const makeWrappedAction =
-  (id: string) =>
+  (id: string, remixVersion: number) =>
   (origAction: DataFunction): DataFunction => {
-    return makeWrappedDataFunction(origAction, id, 'action');
+    return makeWrappedDataFunction(origAction, id, 'action', remixVersion);
   };
 
 const makeWrappedLoader =
-  (id: string) =>
+  (id: string, remixVersion: number) =>
   (origLoader: DataFunction): DataFunction => {
-    return makeWrappedDataFunction(origLoader, id, 'loader');
+    return makeWrappedDataFunction(origLoader, id, 'loader', remixVersion);
   };
 
 function getTraceAndBaggage(): { sentryTrace?: string; sentryBaggage?: string } {
@@ -234,42 +252,46 @@ function getTraceAndBaggage(): { sentryTrace?: string; sentryBaggage?: string }
   return {};
 }
 
-function makeWrappedRootLoader(origLoader: DataFunction): DataFunction {
-  return async function (this: unknown, args: DataFunctionArgs): Promise<Response | AppData> {
-    const res = await origLoader.call(this, args);
-    const traceAndBaggage = getTraceAndBaggage();
-
-    if (isDeferredData(res)) {
-      return {
-        ...res.data,
-        ...traceAndBaggage,
-      };
-    }
+function makeWrappedRootLoader(remixVersion: number) {
+  return function (origLoader: DataFunction): DataFunction {
+    return async function (this: unknown, args: DataFunctionArgs): Promise<Response | AppData> {
+      const res = await origLoader.call(this, args);
+      const traceAndBaggage = getTraceAndBaggage();
+
+      if (isDeferredData(res)) {
+        return {
+          ...res.data,
+          ...traceAndBaggage,
+          remixVersion,
+        };
+      }
 
-    if (isResponse(res)) {
-      // Note: `redirect` and `catch` responses do not have bodies to extract.
-      // We skip injection of trace and baggage in those cases.
-      // For `redirect`, a valid internal redirection target will have the trace and baggage injected.
-      if (isRedirectResponse(res) || isCatchResponse(res)) {
-        __DEBUG_BUILD__ && logger.warn('Skipping injection of trace and baggage as the response does not have a body');
-        return res;
-      } else {
-        const data = await extractData(res);
-
-        if (typeof data === 'object') {
-          return json(
-            { ...data, ...traceAndBaggage },
-            { headers: res.headers, statusText: res.statusText, status: res.status },
-          );
-        } else {
+      if (isResponse(res)) {
+        // Note: `redirect` and `catch` responses do not have bodies to extract.
+        // We skip injection of trace and baggage in those cases.
+        // For `redirect`, a valid internal redirection target will have the trace and baggage injected.
+        if (isRedirectResponse(res) || isCatchResponse(res)) {
           __DEBUG_BUILD__ &&
-            logger.warn('Skipping injection of trace and baggage as the response body is not an object');
+            logger.warn('Skipping injection of trace and baggage as the response does not have a body');
           return res;
+        } else {
+          const data = await extractData(res);
+
+          if (typeof data === 'object') {
+            return json(
+              { ...data, ...traceAndBaggage, remixVersion },
+              { headers: res.headers, statusText: res.statusText, status: res.status },
+            );
+          } else {
+            __DEBUG_BUILD__ &&
+              logger.warn('Skipping injection of trace and baggage as the response body is not an object');
+            return res;
+          }
         }
       }
-    }
 
-    return { ...res, ...traceAndBaggage };
+      return { ...res, ...traceAndBaggage, remixVersion };
+    };
   };
 }
 
@@ -388,7 +410,10 @@ function wrapRequestHandler(origRequestHandler: RequestHandler, build: ServerBui
 
       const res = (await origRequestHandler.call(this, request, loadContext)) as Response;
 
-      transaction.setHttpStatus(res.status);
+      if (isResponse(res)) {
+        transaction.setHttpStatus(res.status);
+      }
+
       transaction.finish();
 
       return res;
@@ -402,6 +427,9 @@ function wrapRequestHandler(origRequestHandler: RequestHandler, build: ServerBui
 export function instrumentBuild(build: ServerBuild): ServerBuild {
   const routes: ServerRouteManifest = {};
 
+  const remixVersion = getRemixVersionFromBuild(build);
+  IS_REMIX_V2 = remixVersion === 2;
+
   const wrappedEntry = { ...build.entry, module: { ...build.entry.module } };
 
   // Not keeping boolean flags like it's done for `requestHandler` functions,
@@ -410,7 +438,7 @@ export function instrumentBuild(build: ServerBuild): ServerBuild {
   // We should be able to wrap them, as they may not be wrapped before.
   const defaultExport = wrappedEntry.module.default as undefined | WrappedFunction;
   if (defaultExport && !defaultExport.__sentry_original__) {
-    fill(wrappedEntry.module, 'default', makeWrappedDocumentRequestFunction);
+    fill(wrappedEntry.module, 'default', makeWrappedDocumentRequestFunction(remixVersion));
   }
 
   for (const [id, route] of Object.entries(build.routes)) {
@@ -418,12 +446,12 @@ export function instrumentBuild(build: ServerBuild): ServerBuild {
 
     const routeAction = wrappedRoute.module.action as undefined | WrappedFunction;
     if (routeAction && !routeAction.__sentry_original__) {
-      fill(wrappedRoute.module, 'action', makeWrappedAction(id));
+      fill(wrappedRoute.module, 'action', makeWrappedAction(id, remixVersion));
     }
 
     const routeLoader = wrappedRoute.module.loader as undefined | WrappedFunction;
     if (routeLoader && !routeLoader.__sentry_original__) {
-      fill(wrappedRoute.module, 'loader', makeWrappedLoader(id));
+      fill(wrappedRoute.module, 'loader', makeWrappedLoader(id, remixVersion));
     }
 
     // Entry module should have a loader function to provide `sentry-trace` and `baggage`
@@ -434,7 +462,7 @@ export function instrumentBuild(build: ServerBuild): ServerBuild {
       }
 
       // We want to wrap the root loader regardless of whether it's already wrapped before.
-      fill(wrappedRoute.module, 'loader', makeWrappedRootLoader);
+      fill(wrappedRoute.module, 'loader', makeWrappedRootLoader(remixVersion));
     }
 
     routes[id] = wrappedRoute;
diff --git a/packages/remix/src/utils/metadata.ts b/packages/remix/src/utils/metadata.ts
index 382eff9c3e26..3270e1c983cc 100644
--- a/packages/remix/src/utils/metadata.ts
+++ b/packages/remix/src/utils/metadata.ts
@@ -1,5 +1,7 @@
 import { SDK_VERSION } from '@sentry/core';
-import type { Options, SdkInfo } from '@sentry/types';
+import type { SdkInfo } from '@sentry/types';
+
+import type { RemixOptions } from './remixOptions';
 
 const PACKAGE_NAME_PREFIX = 'npm:@sentry/';
 
@@ -8,7 +10,7 @@ const PACKAGE_NAME_PREFIX = 'npm:@sentry/';
  * @param options sdk options object that gets mutated
  * @param names list of package names
  */
-export function buildMetadata(options: Options, names: string[]): void {
+export function buildMetadata(options: RemixOptions, names: string[]): void {
   options._metadata = options._metadata || {};
   options._metadata.sdk =
     options._metadata.sdk ||
diff --git a/packages/remix/src/utils/vendor/response.ts b/packages/remix/src/utils/vendor/response.ts
index fbcffedf0fdd..5def5cd28d99 100644
--- a/packages/remix/src/utils/vendor/response.ts
+++ b/packages/remix/src/utils/vendor/response.ts
@@ -6,7 +6,7 @@
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-import type { DeferredData, ReactRouterDomPkg, RouteMatch, ServerRoute } from './types';
+import type { DeferredData, ErrorResponse, ReactRouterDomPkg, RouteMatch, ServerRoute } from './types';
 
 /**
  * Based on Remix Implementation
@@ -140,3 +140,22 @@ export function isDeferredData(value: any): value is DeferredData {
     typeof deferred.resolveData === 'function'
   );
 }
+
+/**
+ * https://github.com/remix-run/react-router/blob/f9b3dbd9cbf513366c456b33d95227f42f36da63/packages/router/utils.ts#L1574
+ *
+ * Check if the given error is an ErrorResponse generated from a 4xx/5xx
+ * Response thrown from an action/loader
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isRouteErrorResponse(value: any): value is ErrorResponse {
+  const error: ErrorResponse = value;
+
+  return (
+    error != null &&
+    typeof error.status === 'number' &&
+    typeof error.statusText === 'string' &&
+    typeof error.internal === 'boolean' &&
+    'data' in error
+  );
+}
diff --git a/packages/remix/test/integration/app_v2/entry.server.tsx b/packages/remix/test/integration/app_v2/entry.server.tsx
index 784cb2a39cd4..71f9ec7c3d67 100644
--- a/packages/remix/test/integration/app_v2/entry.server.tsx
+++ b/packages/remix/test/integration/app_v2/entry.server.tsx
@@ -12,11 +12,7 @@ Sentry.init({
 });
 
 export function handleError(error: unknown, { request }: DataFunctionArgs): void {
-  if (error instanceof Error) {
-    Sentry.captureRemixServerException(error, 'remix.server', request);
-  } else {
-    Sentry.captureException(error);
-  }
+  Sentry.captureRemixServerException(error, 'remix.server', request);
 }
 
 export default function handleRequest(