diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4ea215a28..0bba93e21 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,27 @@
 
 ## Unreleased
 
+### Features
+
+- Alpha support for Hermes JavaScript Profiling ([#3057](https://github.com/getsentry/sentry-react-native/pull/3057))
+
+  Profiling is disabled by default. To enable it, configure both
+  `tracesSampleRate` and `profilesSampleRate` when initializing the SDK:
+
+  ```javascript
+    Sentry.init({
+      dsn: '__DSN__',
+      tracesSampleRate: 1.0,
+      _experiments: {
+        // The sampling rate for profiling is relative to TracesSampleRate.
+        // In this case, we'll capture profiles for 100% of transactions.
+        profilesSampleRate: 1.0,
+      },
+    });
+  ```
+
+  More documentation on profiling and current limitations [can be found here](https://docs.sentry.io/platforms/react-native/profiling/).
+
 ### Fixes
 
 - Warn users about multiple versions of `promise` package which can cause unexpected behavior like undefined `Promise.allSettled` ([#3162](https://github.com/getsentry/sentry-react-native/pull/3162))
diff --git a/RNSentry.podspec b/RNSentry.podspec
index 6073d3ffd..24fed7ec5 100644
--- a/RNSentry.podspec
+++ b/RNSentry.podspec
@@ -1,7 +1,12 @@
 require 'json'
 version = JSON.parse(File.read('package.json'))["version"]
 
-folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+folly_flags = ' -DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1'
+folly_compiler_flags = folly_flags + ' ' + '-Wno-comma -Wno-shorten-64-to-32'
+
+is_new_arch_enabled = ENV["RCT_NEW_ARCH_ENABLED"] == "1"
+new_arch_enabled_flag = (is_new_arch_enabled ? folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED" : "")
+other_cflags = "$(inherited)" + new_arch_enabled_flag
 
 Pod::Spec.new do |s|
   s.name           = 'RNSentry'
@@ -24,9 +29,9 @@ Pod::Spec.new do |s|
   s.source_files = 'ios/**/*.{h,mm}'
   s.public_header_files = 'ios/RNSentry.h'
 
+  s.compiler_flags = other_cflags
   # This guard prevent to install the dependencies when we run `pod install` in the old architecture.
-  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
-    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+  if is_new_arch_enabled then
     s.pod_target_xcconfig    = {
         "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
         "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
diff --git a/android/src/main/java/io/sentry/react/RNSentryModuleImpl.java b/android/src/main/java/io/sentry/react/RNSentryModuleImpl.java
index 5092969d0..845fc76ec 100644
--- a/android/src/main/java/io/sentry/react/RNSentryModuleImpl.java
+++ b/android/src/main/java/io/sentry/react/RNSentryModuleImpl.java
@@ -11,6 +11,7 @@
 
 import androidx.core.app.FrameMetricsAggregator;
 
+import com.facebook.hermes.instrumentation.HermesSamplingProfiler;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -27,7 +28,11 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.File;
 import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
 import java.io.InputStream;
 import java.nio.charset.Charset;
 import java.util.HashMap;
@@ -610,6 +615,61 @@ public void disableNativeFramesTracking() {
         }
     }
 
+    public WritableMap startProfiling() {
+        final WritableMap result = new WritableNativeMap();
+        try {
+            HermesSamplingProfiler.enable();
+            result.putBoolean("started", true);
+        } catch (Throwable e) {
+            result.putBoolean("started", false);
+            result.putString("error", e.toString());
+        }
+        return result;
+    }
+
+    public WritableMap stopProfiling() {
+        final boolean isDebug = HubAdapter.getInstance().getOptions().isDebug();
+        final WritableMap result = new WritableNativeMap();
+        File output = null;
+        try {
+            HermesSamplingProfiler.disable();
+
+            output = File.createTempFile(
+                "sampling-profiler-trace", ".cpuprofile", reactApplicationContext.getCacheDir());
+
+            if (isDebug) {
+                logger.log(SentryLevel.INFO, "Profile saved to: " + output.getAbsolutePath());
+            }
+
+            try (final BufferedReader br = new BufferedReader(new FileReader(output));) {
+                HermesSamplingProfiler.dumpSampledTraceToFile(output.getPath());
+
+                final StringBuilder text = new StringBuilder();
+                String line;
+                while ((line = br.readLine()) != null) {
+                    text.append(line);
+                    text.append('\n');
+                }
+
+                result.putString("profile", text.toString());
+            }
+        } catch (Throwable e) {
+            result.putString("error", e.toString());
+        } finally {
+            if (output != null) {
+                try {
+                    final boolean wasProfileSuccessfullyDeleted = output.delete();
+                    if (!wasProfileSuccessfullyDeleted) {
+                       logger.log(SentryLevel.WARNING, "Profile not deleted from:" + output.getAbsolutePath());
+                    }
+                } catch (Throwable e) {
+                    logger.log(SentryLevel.WARNING, "Profile not deleted from:" + output.getAbsolutePath());
+                }
+            }
+        }
+        return result;
+    }
+
     public void fetchNativeDeviceContexts(Promise promise) {
         final @NotNull SentryOptions options = HubAdapter.getInstance().getOptions();
         if (!(options instanceof SentryAndroidOptions)) {
diff --git a/android/src/newarch/java/io/sentry/react/RNSentryModule.java b/android/src/newarch/java/io/sentry/react/RNSentryModule.java
index e167de797..0310f537a 100644
--- a/android/src/newarch/java/io/sentry/react/RNSentryModule.java
+++ b/android/src/newarch/java/io/sentry/react/RNSentryModule.java
@@ -2,10 +2,12 @@
 
 import androidx.annotation.NonNull;
 
+import com.facebook.react.bridge.JavaScriptExecutorFactory;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.WritableMap;
 
 public class RNSentryModule extends NativeRNSentrySpec {
 
@@ -121,4 +123,14 @@ public void fetchNativeDeviceContexts(Promise promise) {
     public void fetchNativeSdkInfo(Promise promise) {
         this.impl.fetchNativeSdkInfo(promise);
     }
+
+    @Override
+    public WritableMap startProfiling() {
+        return this.impl.startProfiling();
+    }
+
+    @Override
+    public WritableMap stopProfiling() {
+        return this.impl.stopProfiling();
+    }
 }
diff --git a/android/src/oldarch/java/io/sentry/react/RNSentryModule.java b/android/src/oldarch/java/io/sentry/react/RNSentryModule.java
index f6aa57802..3f0d70863 100644
--- a/android/src/oldarch/java/io/sentry/react/RNSentryModule.java
+++ b/android/src/oldarch/java/io/sentry/react/RNSentryModule.java
@@ -7,6 +7,7 @@
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableMap;
 
 public class RNSentryModule extends ReactContextBaseJavaModule {
 
@@ -121,4 +122,14 @@ public void fetchNativeDeviceContexts(Promise promise) {
     public void fetchNativeSdkInfo(Promise promise) {
         this.impl.fetchNativeSdkInfo(promise);
     }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public WritableMap startProfiling() {
+        return this.impl.startProfiling();
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public WritableMap stopProfiling() {
+        return this.impl.stopProfiling();
+    }
 }
diff --git a/ios/RNSentry.mm b/ios/RNSentry.mm
index c2bd9cf69..8afe998f4 100644
--- a/ios/RNSentry.mm
+++ b/ios/RNSentry.mm
@@ -11,6 +11,17 @@
 #import <Sentry/SentryScreenFrames.h>
 #import <Sentry/SentryOptions+HybridSDKs.h>
 
+#if __has_include(<hermes/hermes.h>)
+#define SENTRY_PROFILING_ENABLED 1
+#else
+#define SENTRY_PROFILING_ENABLED 0
+#endif
+
+// This guard prevents importing Hermes in JSC apps
+#if SENTRY_PROFILING_ENABLED
+#import <hermes/hermes.h>
+#endif
+
 // Thanks to this guard, we won't import this header when we build for the old architecture.
 #ifdef RCT_NEW_ARCH_ENABLED
 #import "RNSentrySpec.h"
@@ -498,6 +509,57 @@ - (void)setEventEnvironmentTag:(SentryEvent *)event
     // the 'tracesSampleRate' or 'tracesSampler' option.
 }
 
+static NSString* const enabledProfilingMessage = @"Enable Hermes to use Sentry Profiling.";
+
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, startProfiling)
+{
+#if SENTRY_PROFILING_ENABLED
+    try {
+        facebook::hermes::HermesRuntime::enableSamplingProfiler();
+        return @{ @"started": @YES };
+    } catch (const std::exception& ex) {
+        return @{ @"error": [NSString stringWithCString: ex.what() encoding:[NSString defaultCStringEncoding]] };
+    } catch (...) {
+        return @{ @"error": @"Failed to start profiling" };
+    }
+#else
+    return @{ @"error": enabledProfilingMessage };
+#endif
+}
+
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, stopProfiling)
+{
+#if SENTRY_PROFILING_ENABLED
+    try {
+        facebook::hermes::HermesRuntime::disableSamplingProfiler();
+        std::stringstream ss;
+        facebook::hermes::HermesRuntime::dumpSampledTraceToStream(ss);
+
+        std::string s = ss.str();
+        NSString *data = [NSString stringWithCString:s.c_str() encoding:[NSString defaultCStringEncoding]];
+
+#if SENTRY_PROFILING_DEBUG_ENABLED
+        NSString *rawProfileFileName = @"hermes.profile";
+        NSError *error = nil;
+        NSString *rawProfileFilePath = [NSTemporaryDirectory() stringByAppendingPathComponent:rawProfileFileName];
+        if (![data writeToFile:rawProfileFilePath atomically:YES encoding:NSUTF8StringEncoding error:&error]) {
+            NSLog(@"Error writing Raw Hermes Profile to %@: %@", rawProfileFilePath, error);
+        } else {
+            NSLog(@"Raw Hermes Profile saved to %@", rawProfileFilePath);
+        }
+#endif
+
+        return @{ @"profile": data };
+    } catch (const std::exception& ex) {
+        return @{ @"error": [NSString stringWithCString: ex.what() encoding:[NSString defaultCStringEncoding]] };
+    } catch (...) {
+        return @{ @"error": @"Failed to stop profiling" };
+    }
+#else
+    return @{ @"error": enabledProfilingMessage };
+#endif
+}
+
 // Thanks to this guard, we won't compile this code when we build for the old architecture.
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
diff --git a/package.json b/package.json
index 5a5186983..e6308c253 100644
--- a/package.json
+++ b/package.json
@@ -33,7 +33,8 @@
     "lint:prettier": "prettier --check \"{src,test,scripts}/**/**.ts\"",
     "test:watch": "jest --watch",
     "run-ios": "cd sample-new-architecture && yarn react-native run-ios",
-    "run-android": "cd sample-new-architecture && yarn react-native run-android"
+    "run-android": "cd sample-new-architecture && yarn react-native run-android",
+    "yalc:add:sentry-javascript": "yalc add @sentry/browser @sentry/core @sentry/hub @sentry/integrations @sentry/react @sentry/types @sentry/utils"
   },
   "keywords": [
     "react-native",
diff --git a/sample-new-architecture/android/app/src/main/java/com/samplenewarchitecture/MainApplication.java b/sample-new-architecture/android/app/src/main/java/com/samplenewarchitecture/MainApplication.java
index cae11eb38..ca8e4259f 100644
--- a/sample-new-architecture/android/app/src/main/java/com/samplenewarchitecture/MainApplication.java
+++ b/sample-new-architecture/android/app/src/main/java/com/samplenewarchitecture/MainApplication.java
@@ -1,21 +1,27 @@
 package com.samplenewarchitecture;
 
 import android.app.Application;
+
+import com.facebook.hermes.reactexecutor.HermesExecutorFactory;
 import com.facebook.react.PackageList;
 import com.facebook.react.ReactApplication;
 import com.facebook.react.ReactNativeHost;
 import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptExecutor;
+import com.facebook.react.bridge.JavaScriptExecutorFactory;
+import com.facebook.react.common.JavascriptException;
 import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint;
 import com.facebook.react.defaults.DefaultReactNativeHost;
 import com.facebook.soloader.SoLoader;
 import java.util.List;
 
+import io.sentry.react.RNSentryModuleImpl;
 import io.sentry.react.RNSentryPackage;
 
 public class MainApplication extends Application implements ReactApplication {
-
   private final ReactNativeHost mReactNativeHost =
       new DefaultReactNativeHost(this) {
+
         @Override
         public boolean getUseDeveloperSupport() {
           return BuildConfig.DEBUG;
diff --git a/sample-new-architecture/package.json b/sample-new-architecture/package.json
index 727db2a13..762e9aac9 100644
--- a/sample-new-architecture/package.json
+++ b/sample-new-architecture/package.json
@@ -11,7 +11,8 @@
     "pod-install": "cd ios; RCT_NEW_ARCH_ENABLED=1 bundle exec pod install; cd ..",
     "pod-install-production": "cd ios; PRODUCTION=1 RCT_NEW_ARCH_ENABLED=1 bundle exec pod install; cd ..",
     "pod-install-legacy": "cd ios; bundle exec pod install; cd ..",
-    "pod-install-legacy-production": "cd ios; PRODUCTION=1 bundle exec pod install; cd .."
+    "pod-install-legacy-production": "cd ios; PRODUCTION=1 bundle exec pod install; cd ..",
+    "clean-ios": "cd ios; rm -rf Podfile.lock Pods build; cd .."
   },
   "dependencies": {
     "@react-navigation/native": "^6.1.7",
diff --git a/sample-new-architecture/src/App.tsx b/sample-new-architecture/src/App.tsx
index 5ebd06949..6c52b98ed 100644
--- a/sample-new-architecture/src/App.tsx
+++ b/sample-new-architecture/src/App.tsx
@@ -31,7 +31,7 @@ Sentry.init({
   dsn: SENTRY_INTERNAL_DSN,
   debug: true,
   beforeSend: (event: Sentry.Event) => {
-    console.log('Event beforeSend:', event);
+    console.log('Event beforeSend:', event.event_id);
     return event;
   },
   // This will be called with a boolean `didCallNativeInit` when the native SDK has been contacted.
@@ -85,6 +85,9 @@ Sentry.init({
   // otherwise they will not work.
   // release: 'myapp@1.2.3+1',
   // dist: `1`,
+  _experiments: {
+    profilesSampleRate: 1,
+  },
 });
 
 const Stack = createStackNavigator();
diff --git a/sample-new-architecture/src/Screens/HomeScreen.tsx b/sample-new-architecture/src/Screens/HomeScreen.tsx
index 31c5f72cd..0d57b5191 100644
--- a/sample-new-architecture/src/Screens/HomeScreen.tsx
+++ b/sample-new-architecture/src/Screens/HomeScreen.tsx
@@ -128,7 +128,6 @@ const HomeScreen = (props: Props) => {
           />
         )}
         <Spacer />
-
         <Sentry.ErrorBoundary fallback={errorBoundaryFallback}>
           <Button
             title="Activate Error Boundary"
diff --git a/scripts/hermes-profile-transformer.js b/scripts/hermes-profile-transformer.js
new file mode 100644
index 000000000..10efe8744
--- /dev/null
+++ b/scripts/hermes-profile-transformer.js
@@ -0,0 +1,26 @@
+const { writeFileSync } = require('fs');
+
+const transformer = require('hermes-profile-transformer').default;
+
+const hermesCpuProfilePath = 'iOS_release_profile.json';
+const sourceMapPath = './main.jsbundle.map';
+const sourceMapBundleFileName = 'main.jsbundle';
+
+transformer(
+  // profile path is required
+  hermesCpuProfilePath,
+  // source maps are optional
+  sourceMapPath,
+  sourceMapBundleFileName
+)
+  .then(events => {
+    // write converted trace to a file
+    return writeFileSync(
+      './chrome-supported.json',
+      JSON.stringify(events, null, 2),
+      'utf-8'
+    );
+  })
+  .catch(err => {
+    console.log(err);
+  });
diff --git a/src/js/NativeRNSentry.ts b/src/js/NativeRNSentry.ts
index d9e8cec9f..be3c11c12 100644
--- a/src/js/NativeRNSentry.ts
+++ b/src/js/NativeRNSentry.ts
@@ -31,6 +31,8 @@ export interface Spec extends TurboModule {
   enableNativeFramesTracking(): void;
   fetchModules(): Promise<string | undefined | null>;
   fetchViewHierarchy(): Promise<number[] | undefined | null>;
+  startProfiling(): { started?: boolean; error?: string };
+  stopProfiling(): { profile?: string; error?: string };
 }
 
 export type NativeAppStartResponse = {
diff --git a/src/js/client.ts b/src/js/client.ts
index 89cfd915e..9e42696c8 100644
--- a/src/js/client.ts
+++ b/src/js/client.ts
@@ -138,6 +138,8 @@ export class ReactNativeClient extends BaseClient<ReactNativeClientOptions> {
 
     let shouldClearOutcomesBuffer = true;
     if (this._transport && this._dsn) {
+      this.emit('beforeEnvelope', envelope);
+
       this._transport.send(envelope).then(null, reason => {
         if (reason instanceof SentryError) {
           // SentryError is thrown by SyncPromise
diff --git a/src/js/integrations/index.ts b/src/js/integrations/index.ts
index 92f8b0eb3..061bc5e0a 100644
--- a/src/js/integrations/index.ts
+++ b/src/js/integrations/index.ts
@@ -6,3 +6,4 @@ export { EventOrigin } from './eventorigin';
 export { SdkInfo } from './sdkinfo';
 export { ReactNativeInfo } from './reactnativeinfo';
 export { ModulesLoader } from './modulesloader';
+export { HermesProfiling } from '../profiling/integration';
diff --git a/src/js/integrations/rewriteframes.ts b/src/js/integrations/rewriteframes.ts
index 7fbf250e9..2c9ad2a9d 100644
--- a/src/js/integrations/rewriteframes.ts
+++ b/src/js/integrations/rewriteframes.ts
@@ -4,8 +4,8 @@ import { Platform } from 'react-native';
 
 import { isExpo } from '../utils/environment';
 
-const ANDROID_DEFAULT_BUNDLE_NAME = 'app:///index.android.bundle';
-const IOS_DEFAULT_BUNDLE_NAME = 'app:///main.jsbundle';
+export const ANDROID_DEFAULT_BUNDLE_NAME = 'app:///index.android.bundle';
+export const IOS_DEFAULT_BUNDLE_NAME = 'app:///main.jsbundle';
 
 /**
  * Creates React Native default rewrite frames integration
diff --git a/src/js/profiling/cache.ts b/src/js/profiling/cache.ts
new file mode 100644
index 000000000..ef64b18c2
--- /dev/null
+++ b/src/js/profiling/cache.ts
@@ -0,0 +1,5 @@
+import { makeFifoCache } from '@sentry/utils';
+
+import type { RawThreadCpuProfile } from './types';
+
+export const PROFILE_QUEUE = makeFifoCache<string, RawThreadCpuProfile>(20);
diff --git a/src/js/profiling/convertHermesProfile.ts b/src/js/profiling/convertHermesProfile.ts
new file mode 100644
index 000000000..286b09e6f
--- /dev/null
+++ b/src/js/profiling/convertHermesProfile.ts
@@ -0,0 +1,185 @@
+import type { FrameId, StackId, ThreadCpuFrame, ThreadCpuSample, ThreadCpuStack, ThreadId } from '@sentry/types';
+import { logger } from '@sentry/utils';
+import { Platform } from 'react-native';
+
+import { ANDROID_DEFAULT_BUNDLE_NAME, IOS_DEFAULT_BUNDLE_NAME } from '../integrations/rewriteframes';
+import type * as Hermes from './hermes';
+import { parseHermesStackFrameFunctionName } from './hermes';
+import { MAX_PROFILE_DURATION_MS } from './integration';
+import type { RawThreadCpuProfile } from './types';
+
+const MS_TO_NS = 1e6;
+const MAX_PROFILE_DURATION_NS = MAX_PROFILE_DURATION_MS * MS_TO_NS;
+const ANONYMOUS_FUNCTION_NAME = 'anonymous';
+const UNKNOWN_STACK_ID = -1;
+const JS_THREAD_NAME = 'JavaScriptThread';
+const JS_THREAD_PRIORITY = 1;
+const DEFAULT_BUNDLE_NAME =
+  Platform.OS === 'android' ? ANDROID_DEFAULT_BUNDLE_NAME : Platform.OS === 'ios' ? IOS_DEFAULT_BUNDLE_NAME : undefined;
+
+/**
+ * Converts a Hermes profile to a Sentry profile.
+ *
+ * Maps Hermes samples to Sentry samples.
+ * Maps Hermes stack frames to Sentry frames.
+ * Hermes stack frame is an object representing a function call in the stack
+ * with a link to its parent stack frame. Root of the represented stack tree
+ * is main function call in Hermes that is [root] stack frame.
+ *
+ * @returns Sentry profile or null if no samples are found.
+ */
+export function convertToSentryProfile(hermesProfile: Hermes.Profile): RawThreadCpuProfile | null {
+  if (hermesProfile.samples.length === 0) {
+    logger.warn('[Profiling] No samples found in profile.');
+    return null;
+  }
+
+  const { samples, hermesStacks, jsThreads } = mapSamples(hermesProfile.samples);
+
+  const { frames, hermesStackFrameIdToSentryFrameIdMap } = mapFrames(hermesProfile.stackFrames);
+
+  const { stacks, hermesStackToSentryStackMap } = mapStacks(
+    hermesStacks,
+    hermesProfile.stackFrames,
+    hermesStackFrameIdToSentryFrameIdMap,
+  );
+
+  for (const sample of samples) {
+    const sentryStackId = hermesStackToSentryStackMap.get(sample.stack_id);
+    if (sentryStackId === undefined) {
+      logger.error(`[Profiling] Hermes Stack ID ${sample.stack_id} not found when mapping to Sentry Stack ID.`);
+      sample.stack_id = UNKNOWN_STACK_ID;
+    } else {
+      sample.stack_id = sentryStackId;
+    }
+  }
+
+  const thread_metadata: Record<ThreadId, { name?: string; priority?: number }> = {};
+  for (const jsThreadId of jsThreads) {
+    thread_metadata[jsThreadId] = {
+      name: JS_THREAD_NAME,
+      priority: JS_THREAD_PRIORITY,
+    };
+  }
+
+  return {
+    samples,
+    frames,
+    stacks,
+    thread_metadata,
+  };
+}
+
+/**
+ * Maps Hermes samples to Sentry samples.
+ * Calculates the elapsed time since the first sample based on the absolute timestamps of the Hermes samples.
+ * Hermes stack frame IDs represent the last (leaf, furthest from the main func) frame of the call stack.
+ * @returns the mapped Sentry samples, the set of Hermes stack frame IDs, and the set of JS thread IDs
+ */
+export function mapSamples(
+  hermesSamples: Hermes.Sample[],
+  maxElapsedSinceStartNs: number = MAX_PROFILE_DURATION_NS,
+): {
+  samples: ThreadCpuSample[];
+  hermesStacks: Set<Hermes.StackFrameId>;
+  jsThreads: Set<ThreadId>;
+} {
+  const jsThreads = new Set<ThreadId>();
+  const hermesStacks = new Set<Hermes.StackFrameId>();
+
+  const start = Number(hermesSamples[0].ts);
+  const samples: ThreadCpuSample[] = [];
+  for (const hermesSample of hermesSamples) {
+    jsThreads.add(hermesSample.tid);
+    hermesStacks.add(hermesSample.sf);
+
+    const elapsed_since_start_ns = (Number(hermesSample.ts) - start) * 1e3;
+    if (elapsed_since_start_ns >= maxElapsedSinceStartNs) {
+      logger.warn(
+        `[Profiling] Sample has elapsed time since start ${elapsed_since_start_ns}ns ` +
+          `greater than the max elapsed time ${maxElapsedSinceStartNs}ns.`,
+      );
+      break;
+    }
+
+    samples.push({
+      stack_id: hermesSample.sf,
+      thread_id: hermesSample.tid,
+      elapsed_since_start_ns: elapsed_since_start_ns.toFixed(0),
+    });
+  }
+
+  return {
+    samples,
+    hermesStacks,
+    jsThreads,
+  };
+}
+
+/**
+ * Maps Hermes StackFrames tree represented as an JS object to a Sentry frames array.
+ * Converts line and columns strings to numbers.
+ * @returns the mapped Sentry frames
+ */
+function mapFrames(hermesStackFrames: Record<Hermes.StackFrameId, Hermes.StackFrame>): {
+  frames: ThreadCpuFrame[];
+  hermesStackFrameIdToSentryFrameIdMap: Map<Hermes.StackFrameId, FrameId>;
+} {
+  const frames: ThreadCpuFrame[] = [];
+  const hermesStackFrameIdToSentryFrameIdMap = new Map<Hermes.StackFrameId, FrameId>();
+  for (const key in hermesStackFrames) {
+    // asc order based on the key is not guaranteed
+    if (!Object.prototype.hasOwnProperty.call(hermesStackFrames, key)) {
+      continue;
+    }
+    hermesStackFrameIdToSentryFrameIdMap.set(Number(key), frames.length);
+    const hermesFrame = hermesStackFrames[key];
+
+    const functionName = parseHermesStackFrameFunctionName(hermesFrame.name);
+    frames.push({
+      function: functionName || ANONYMOUS_FUNCTION_NAME,
+      file: hermesFrame.category == 'JavaScript' ? DEFAULT_BUNDLE_NAME : undefined,
+      line: hermesFrame.line !== undefined ? Number(hermesFrame.line) : undefined,
+      column: hermesFrame.column !== undefined ? Number(hermesFrame.column) : undefined,
+    });
+  }
+
+  return {
+    frames,
+    hermesStackFrameIdToSentryFrameIdMap,
+  };
+}
+
+/**
+ * Maps Hermes stack frame IDs to Sentry stack arrays.
+ * Hermes stack frame IDs represent the last (leaf, furthest from the main func) frame of the call stack.
+ * @returns the mapped Sentry stacks and a map from Hermes stack IDs to Sentry stack IDs (indices in the stacks array)
+ */
+function mapStacks(
+  hermesStacks: Set<Hermes.StackFrameId>,
+  hermesStackFrames: Record<Hermes.StackFrameId, Hermes.StackFrame>,
+  hermesStackFrameIdToSentryFrameIdMap: Map<Hermes.StackFrameId, FrameId>,
+): {
+  stacks: ThreadCpuStack[];
+  hermesStackToSentryStackMap: Map<Hermes.StackFrameId, StackId>;
+} {
+  const hermesStackToSentryStackMap = new Map<Hermes.StackFrameId, StackId>();
+  const stacks: ThreadCpuStack[] = [];
+  for (const hermesStackFunctionFrameId of hermesStacks) {
+    const stackId = stacks.length;
+    hermesStackToSentryStackMap.set(hermesStackFunctionFrameId, stackId);
+    const stack: ThreadCpuStack = [];
+    let currentHermesFrameId: Hermes.StackFrameId | undefined = hermesStackFunctionFrameId;
+    while (currentHermesFrameId !== undefined) {
+      const sentryFrameId = hermesStackFrameIdToSentryFrameIdMap.get(currentHermesFrameId);
+      sentryFrameId !== undefined && stack.push(sentryFrameId);
+      currentHermesFrameId = hermesStackFrames[currentHermesFrameId] && hermesStackFrames[currentHermesFrameId].parent;
+    }
+    stacks.push(stack);
+  }
+
+  return {
+    stacks,
+    hermesStackToSentryStackMap,
+  };
+}
diff --git a/src/js/profiling/hermes.ts b/src/js/profiling/hermes.ts
new file mode 100644
index 000000000..cee35924b
--- /dev/null
+++ b/src/js/profiling/hermes.ts
@@ -0,0 +1,81 @@
+import { NATIVE } from '../wrapper';
+import { convertToSentryProfile } from './convertHermesProfile';
+import type { RawThreadCpuProfile } from './types';
+
+export type StackFrameId = number;
+export type MicrosecondsSinceBoot = string;
+
+export interface TraceEvent {
+  name: string;
+  ph: string;
+  cat: string;
+  pid: number;
+  ts: MicrosecondsSinceBoot;
+  tid: string;
+  args: {
+    name?: string;
+  };
+}
+
+export interface Sample {
+  cpu: string;
+  name: string;
+  ts: MicrosecondsSinceBoot;
+  pid: number;
+  tid: string;
+  weight: string;
+  sf: StackFrameId;
+}
+
+export interface StackFrame {
+  line?: string;
+  column?: string;
+  funcLine?: string;
+  funcColumn?: string;
+  name: string;
+  category: string;
+  parent?: number;
+}
+
+export interface Profile {
+  traceEvents: TraceEvent[];
+  samples: Sample[];
+  stackFrames: Record<string, StackFrame>;
+}
+
+/**
+ * Hermes Profile Stack Frame Name contains function name and file path.
+ *
+ * `foo(/path/to/file.js:1:2)` -> `foo`
+ */
+export function parseHermesStackFrameFunctionName(hermesName: string): string {
+  const indexOfLeftParenthesis = hermesName.indexOf('(');
+  const name = indexOfLeftParenthesis !== -1 ? hermesName.substring(0, indexOfLeftParenthesis) : hermesName;
+  return name;
+}
+
+const MS_TO_NS: number = 1e6;
+
+/**
+ * Starts Hermes Sampling Profiler and returns the timestamp when profiling started in nanoseconds.
+ */
+export function startProfiling(): number | null {
+  const started = NATIVE.startProfiling();
+  if (!started) {
+    return null;
+  }
+
+  const profileStartTimestampNs = Date.now() * MS_TO_NS;
+  return profileStartTimestampNs;
+}
+
+/**
+ * Stops Hermes Sampling Profiler and returns the profile.
+ */
+export function stopProfiling(): RawThreadCpuProfile | null {
+  const hermesProfile = NATIVE.stopProfiling();
+  if (!hermesProfile) {
+    return null;
+  }
+  return convertToSentryProfile(hermesProfile);
+}
diff --git a/src/js/profiling/integration.ts b/src/js/profiling/integration.ts
new file mode 100644
index 000000000..a129dc1bd
--- /dev/null
+++ b/src/js/profiling/integration.ts
@@ -0,0 +1,191 @@
+import type { Envelope, Event, EventProcessor, Hub, Integration, Profile, Transaction } from '@sentry/types';
+import { logger, uuid4 } from '@sentry/utils';
+
+import { isHermesEnabled } from '../utils/environment';
+import { PROFILE_QUEUE } from './cache';
+import { startProfiling, stopProfiling } from './hermes';
+import { addProfilesToEnvelope, createProfilingEvent, findProfiledTransactionsFromEnvelope } from './utils';
+
+export const MAX_PROFILE_DURATION_MS = 30 * 1e3;
+
+/**
+ * Profiling integration creates a profile for each transaction and adds it to the event envelope.
+ *
+ * @experimental
+ */
+export class HermesProfiling implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'HermesProfiling';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = HermesProfiling.id;
+
+  private _getCurrentHub?: () => Hub;
+
+  private _currentProfile:
+    | {
+        profile_id: string;
+        startTimestampNs: number;
+      }
+    | undefined;
+
+  private _currentProfileTimeout: number | undefined;
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(_: (e: EventProcessor) => void, getCurrentHub: () => Hub): void {
+    if (!isHermesEnabled()) {
+      logger.log('[Profiling] Hermes is not enabled, not adding profiling integration.');
+      return;
+    }
+
+    this._getCurrentHub = getCurrentHub;
+    const client = getCurrentHub().getClient();
+
+    if (!client || typeof client.on !== 'function') {
+      return;
+    }
+
+    client.on('startTransaction', (transaction: Transaction) => {
+      this._finishCurrentProfile();
+
+      const shouldStartProfiling = this._shouldStartProfiling(transaction);
+      if (!shouldStartProfiling) {
+        return;
+      }
+
+      this._currentProfileTimeout = setTimeout(this._finishCurrentProfile, MAX_PROFILE_DURATION_MS);
+      this._startNewProfile(transaction);
+    });
+
+    client.on('finishTransaction', () => {
+      this._finishCurrentProfile();
+    });
+
+    client.on('beforeEnvelope', (envelope: Envelope) => {
+      if (!PROFILE_QUEUE.size()) {
+        return;
+      }
+
+      const profiledTransactions = findProfiledTransactionsFromEnvelope(envelope);
+      if (!profiledTransactions.length) {
+        logger.log('[Profiling] no profiled transactions found in envelope');
+        return;
+      }
+
+      const profilesToAddToEnvelope: Profile[] = [];
+      for (const profiledTransaction of profiledTransactions) {
+        const profile = this._createProfileEventFor(profiledTransaction);
+        if (profile) {
+          profilesToAddToEnvelope.push(profile);
+        }
+      }
+      addProfilesToEnvelope(envelope, profilesToAddToEnvelope);
+    });
+  }
+
+  private _shouldStartProfiling = (transaction: Transaction): boolean => {
+    if (!transaction.sampled) {
+      logger.log('[Profiling] Transaction is not sampled, skipping profiling');
+      return false;
+    }
+
+    const client = this._getCurrentHub && this._getCurrentHub().getClient();
+    const options = client && client.getOptions();
+
+    // @ts-ignore not part of the browser options yet
+    const profilesSampleRate =
+      options && options._experiments && typeof options._experiments.profilesSampleRate === 'number'
+        ? options._experiments.profilesSampleRate
+        : undefined;
+    if (profilesSampleRate === undefined) {
+      logger.log('[Profiling] Profiling disabled, enable it by setting `profilesSampleRate` option to SDK init call.');
+      return false;
+    }
+
+    // Check if we should sample this profile
+    if (Math.random() > profilesSampleRate) {
+      logger.log('[Profiling] Skip profiling transaction due to sampling.');
+      return false;
+    }
+
+    return true;
+  };
+
+  /**
+   * Starts a new profile and links it to the transaction.
+   */
+  private _startNewProfile = (transaction: Transaction): void => {
+    const profileStartTimestampNs = startProfiling();
+    if (!profileStartTimestampNs) {
+      return;
+    }
+
+    this._currentProfile = {
+      profile_id: uuid4(),
+      startTimestampNs: profileStartTimestampNs,
+    };
+    transaction.setContext('profile', { profile_id: this._currentProfile.profile_id });
+    // @ts-expect-error profile_id is not part of the metadata type
+    transaction.setMetadata({ profile_id: this._currentProfile.profile_id });
+    logger.log('[Profiling] started profiling: ', this._currentProfile.profile_id);
+  };
+
+  /**
+   * Stops profiling and adds the profile to the queue to be processed on beforeEnvelope.
+   */
+  private _finishCurrentProfile = (): void => {
+    this._clearCurrentProfileTimeout();
+    if (this._currentProfile === undefined) {
+      return;
+    }
+
+    const profile = stopProfiling();
+    if (!profile) {
+      logger.warn('[Profiling] Stop failed. Cleaning up...');
+      this._currentProfile = undefined;
+      return;
+    }
+
+    profile.profile_id = this._currentProfile.profile_id;
+    PROFILE_QUEUE.add(profile.profile_id, profile);
+    logger.log('[Profiling] finished profiling: ', this._currentProfile.profile_id);
+    this._currentProfile = undefined;
+  };
+
+  private _createProfileEventFor = (profiledTransaction: Event): Profile | null => {
+    const profile_id = profiledTransaction?.contexts?.['profile']?.['profile_id'];
+
+    if (typeof profile_id !== 'string') {
+      logger.log('[Profiling] cannot find profile for a transaction without a profile context');
+      return null;
+    }
+
+    // Remove the profile from the transaction context before sending, relay will take care of the rest.
+    if (profiledTransaction?.contexts?.['.profile']) {
+      delete profiledTransaction.contexts.profile;
+    }
+
+    const cpuProfile = PROFILE_QUEUE.get(profile_id);
+    PROFILE_QUEUE.delete(profile_id);
+
+    if (!cpuProfile) {
+      logger.log(`[Profiling] cannot find profile ${profile_id} for transaction ${profiledTransaction.event_id}`);
+      return null;
+    }
+
+    const profile = createProfilingEvent(cpuProfile, profiledTransaction);
+    logger.log(`[Profiling] Created profile ${profile_id} for transaction ${profiledTransaction.event_id}`);
+    return profile;
+  };
+
+  private _clearCurrentProfileTimeout = (): void => {
+    this._currentProfileTimeout !== undefined && clearTimeout(this._currentProfileTimeout);
+    this._currentProfileTimeout = undefined;
+  };
+}
diff --git a/src/js/profiling/types.ts b/src/js/profiling/types.ts
new file mode 100644
index 000000000..0f4c3bda4
--- /dev/null
+++ b/src/js/profiling/types.ts
@@ -0,0 +1,5 @@
+import type { ThreadCpuProfile } from '@sentry/types';
+
+export interface RawThreadCpuProfile extends ThreadCpuProfile {
+  profile_id?: string;
+}
diff --git a/src/js/profiling/utils.ts b/src/js/profiling/utils.ts
new file mode 100644
index 000000000..13ac4af76
--- /dev/null
+++ b/src/js/profiling/utils.ts
@@ -0,0 +1,187 @@
+import type { Envelope, Event, Profile } from '@sentry/types';
+import { forEachEnvelopeItem, logger } from '@sentry/utils';
+
+import type { RawThreadCpuProfile } from './types';
+
+const ACTIVE_THREAD_ID_STRING = '0';
+
+/**
+ *
+ */
+export function isValidProfile(profile: RawThreadCpuProfile): profile is RawThreadCpuProfile & { profile_id: string } {
+  if (profile.samples.length <= 1) {
+    if (__DEV__) {
+      // Log a warning if the profile has less than 2 samples so users can know why
+      // they are not seeing any profiling data and we cant avoid the back and forth
+      // of asking them to provide us with a dump of the profile data.
+      logger.log('[Profiling] Discarding profile because it contains less than 2 samples');
+    }
+    return false;
+  }
+
+  if (!profile.profile_id) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Finds transactions with profile_id context in the envelope
+ * @param envelope
+ * @returns
+ */
+export function findProfiledTransactionsFromEnvelope(envelope: Envelope): Event[] {
+  const events: Event[] = [];
+
+  forEachEnvelopeItem(envelope, (item, type) => {
+    if (type !== 'transaction') {
+      return;
+    }
+
+    // First item is the type
+    for (let j = 1; j < item.length; j++) {
+      const event = item[j];
+
+      // @ts-expect-error accessing private property
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      if (event && event.contexts && event.contexts['profile'] && event.contexts['profile']['profile_id']) {
+        events.push(item[j] as Event);
+      }
+    }
+  });
+
+  return events;
+}
+
+/**
+ * Creates a profiling envelope item, if the profile does not pass validation, returns null.
+ * @param event
+ * @returns {Profile | null}
+ */
+export function createProfilingEvent(profile: RawThreadCpuProfile, event: Event): Profile | null {
+  if (!isValidProfile(profile)) {
+    return null;
+  }
+
+  return createProfilePayload(profile, {
+    release: event.release || '',
+    environment: event.environment || '',
+    event_id: event.event_id || '',
+    transaction: event.transaction || '',
+    start_timestamp: event.start_timestamp ? event.start_timestamp * 1000 : Date.now(),
+    trace_id: (event?.contexts?.trace?.trace_id as string) ?? '',
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    profile_id: profile.profile_id,
+    os_platform: event.contexts?.os?.name || '',
+    os_version: event.contexts?.os?.version || '',
+    os_build: event.contexts?.os?.build || '',
+    device_locale: (event.contexts?.device?.locale as string) || '',
+    device_model: event.contexts?.device?.model || '',
+    device_manufacturer: event.contexts?.device?.manufacturer || '',
+    device_architecture: event.contexts?.device?.arch || '',
+    device_is_emulator: event.contexts?.device?.simulator || false,
+  });
+}
+
+/**
+ * Create a profile
+ * @param profile
+ * @param options
+ * @returns
+ */
+function createProfilePayload(
+  cpuProfile: RawThreadCpuProfile,
+  {
+    release,
+    environment,
+    event_id,
+    transaction,
+    start_timestamp,
+    trace_id,
+    profile_id,
+    os_platform,
+    os_version,
+    os_build,
+    device_locale,
+    device_model,
+    device_manufacturer,
+    device_architecture,
+    device_is_emulator,
+  }: {
+    release: string;
+    environment: string;
+    event_id: string;
+    transaction: string;
+    start_timestamp: number;
+    trace_id: string | undefined;
+    profile_id: string;
+    os_platform: string;
+    os_version: string;
+    os_build?: string;
+    device_locale: string;
+    device_model: string;
+    device_manufacturer: string;
+    device_architecture: string;
+    device_is_emulator: boolean;
+  },
+): Profile {
+  // Log a warning if the profile has an invalid traceId (should be uuidv4).
+  // All profiles and transactions are rejected if this is the case and we want to
+  // warn users that this is happening if they enable debug flag
+  if (trace_id && trace_id.length !== 32) {
+    if (__DEV__) {
+      logger.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
+    }
+  }
+
+  const profile: Profile = {
+    event_id: profile_id,
+    timestamp: new Date(start_timestamp).toISOString(),
+    platform: 'node',
+    version: '1',
+    release: release,
+    environment: environment,
+    runtime: {
+      name: 'hermes',
+      version: '', // TODO: get hermes version
+    },
+    os: {
+      name: os_platform,
+      version: os_version,
+      build_number: os_build,
+    },
+    device: {
+      locale: device_locale,
+      model: device_model,
+      manufacturer: device_manufacturer,
+      architecture: device_architecture,
+      is_emulator: device_is_emulator,
+    },
+    profile: cpuProfile,
+    transaction: {
+      name: transaction,
+      id: event_id,
+      trace_id: trace_id || '',
+      active_thread_id: ACTIVE_THREAD_ID_STRING,
+    },
+  };
+
+  return profile;
+}
+
+/**
+ * Adds items to envelope if they are not already present - mutates the envelope.
+ * @param envelope
+ */
+export function addProfilesToEnvelope(envelope: Envelope, profiles: Profile[]): Envelope {
+  if (!profiles.length) {
+    return envelope;
+  }
+
+  for (const profile of profiles) {
+    // @ts-expect-error untyped envelope
+    envelope[1].push([{ type: 'profile' }, profile]);
+  }
+  return envelope;
+}
diff --git a/src/js/sdk.tsx b/src/js/sdk.tsx
index ada2c99b8..07db97e9a 100644
--- a/src/js/sdk.tsx
+++ b/src/js/sdk.tsx
@@ -16,6 +16,7 @@ import {
   DebugSymbolicator,
   DeviceContext,
   EventOrigin,
+  HermesProfiling,
   ModulesLoader,
   ReactNativeErrorHandlers,
   ReactNativeInfo,
@@ -129,6 +130,9 @@ export function init(passedOptions: ReactNativeOptions): void {
     if (options.enableCaptureFailedRequests) {
       defaultIntegrations.push(new HttpClient());
     }
+    if (options._experiments && typeof options._experiments.profilesSampleRate === 'number') {
+      defaultIntegrations.push(new HermesProfiling());
+    }
   }
 
   options.integrations = getIntegrationsToSetup({
diff --git a/src/js/wrapper.ts b/src/js/wrapper.ts
index b0bc3bf56..3677a0f6f 100644
--- a/src/js/wrapper.ts
+++ b/src/js/wrapper.ts
@@ -22,6 +22,7 @@ import type {
   Spec,
 } from './NativeRNSentry';
 import type { ReactNativeClientOptions } from './options';
+import type * as Hermes from './profiling/hermes';
 import type { RequiredKeysUser } from './user';
 import { isTurboModuleEnabled } from './utils/environment';
 import { utf8ToBytes } from './vendor';
@@ -78,6 +79,9 @@ interface SentryNativeWrapper {
 
   fetchModules(): Promise<Record<string, string> | null>;
   fetchViewHierarchy(): PromiseLike<Uint8Array | null>;
+
+  startProfiling(): boolean;
+  stopProfiling(): Hermes.Profile | null;
 }
 
 /**
@@ -487,6 +491,46 @@ export const NATIVE: SentryNativeWrapper = {
     return raw ? new Uint8Array(raw) : null;
   },
 
+  startProfiling(): boolean {
+    if (!this.enableNative) {
+      throw this._DisabledNativeError;
+    }
+    if (!this._isModuleLoaded(RNSentry)) {
+      throw this._NativeClientError;
+    }
+
+    const { started, error } = RNSentry.startProfiling();
+    if (started) {
+      logger.log('[NATIVE] Start Profiling');
+    } else {
+      logger.error('[NATIVE] Start Profiling Failed', error);
+    }
+
+    return !!started;
+  },
+
+  stopProfiling(): Hermes.Profile | null {
+    if (!this.enableNative) {
+      throw this._DisabledNativeError;
+    }
+    if (!this._isModuleLoaded(RNSentry)) {
+      throw this._NativeClientError;
+    }
+
+    const { profile, error } = RNSentry.stopProfiling();
+    if (!profile || error) {
+      logger.error('[NATIVE] Stop Profiling Failed', error);
+      return null;
+    }
+
+    try {
+      return JSON.parse(profile) as Hermes.Profile;
+    } catch (e) {
+      logger.error('[NATIVE] Failed to parse Hermes Profile JSON', e);
+      return null;
+    }
+  },
+
   /**
    * Gets the event from envelopeItem and applies the level filter to the selected event.
    * @param data An envelope item containing the event.
diff --git a/test/mockDsn.ts b/test/mockDsn.ts
new file mode 100644
index 000000000..a20e7d3e4
--- /dev/null
+++ b/test/mockDsn.ts
@@ -0,0 +1 @@
+export const MOCK_DSN = 'https://6890c2f6677340daa4804f8194804ea2@o19635.ingest.sentry.io/148053';
diff --git a/test/mockWrapper.ts b/test/mockWrapper.ts
new file mode 100644
index 000000000..0d2c6da08
--- /dev/null
+++ b/test/mockWrapper.ts
@@ -0,0 +1,71 @@
+import type { NATIVE as ORIGINAL_NATIVE } from '../src/js/wrapper';
+import type { MockInterface } from './testutils';
+
+type NativeType = typeof ORIGINAL_NATIVE;
+
+const NATIVE: MockInterface<NativeType> = {
+  enableNative: true,
+  nativeIsReady: true,
+  platform: 'ios',
+
+  _NativeClientError: new Error('MockNative client is not available'),
+  _DisabledNativeError: new Error('MockNative is disabled'),
+
+  _processItem: jest.fn(),
+  _processLevels: jest.fn(),
+  _processLevel: jest.fn(),
+  _serializeObject: jest.fn(),
+  _isModuleLoaded: <NativeType['_isModuleLoaded'] & jest.Mock>jest.fn(),
+  _getBreadcrumbs: jest.fn(),
+
+  isNativeAvailable: jest.fn(),
+
+  initNativeSdk: jest.fn(),
+  closeNativeSdk: jest.fn(),
+
+  sendEnvelope: jest.fn(),
+  captureScreenshot: jest.fn(),
+
+  fetchNativeRelease: jest.fn(),
+  fetchNativeDeviceContexts: jest.fn(),
+  fetchNativeAppStart: jest.fn(),
+  fetchNativeFrames: jest.fn(),
+  fetchNativeSdkInfo: jest.fn(),
+
+  disableNativeFramesTracking: jest.fn(),
+  enableNativeFramesTracking: jest.fn(),
+
+  addBreadcrumb: jest.fn(),
+  setContext: jest.fn(),
+  clearBreadcrumbs: jest.fn(),
+  setExtra: jest.fn(),
+  setUser: jest.fn(),
+  setTag: jest.fn(),
+
+  nativeCrash: jest.fn(),
+
+  fetchModules: jest.fn(),
+  fetchViewHierarchy: jest.fn(),
+
+  startProfiling: jest.fn(),
+  stopProfiling: jest.fn(),
+};
+
+NATIVE.isNativeAvailable.mockReturnValue(true);
+NATIVE.initNativeSdk.mockResolvedValue(true);
+NATIVE.captureScreenshot.mockResolvedValue(null);
+NATIVE.fetchNativeRelease.mockResolvedValue({
+  version: 'mock-native-version',
+  build: 'mock-native-build',
+  id: 'mock-native-id',
+});
+NATIVE.fetchNativeDeviceContexts.mockResolvedValue({});
+NATIVE.fetchNativeAppStart.mockResolvedValue(null);
+NATIVE.fetchNativeFrames.mockResolvedValue(null);
+NATIVE.fetchNativeSdkInfo.mockResolvedValue(null);
+NATIVE.fetchModules.mockResolvedValue(null);
+NATIVE.fetchViewHierarchy.mockResolvedValue(null);
+NATIVE.startProfiling.mockReturnValue(false);
+NATIVE.stopProfiling.mockReturnValue(null);
+
+export { NATIVE };
diff --git a/test/profiling/convertHermesProfile.test.ts b/test/profiling/convertHermesProfile.test.ts
new file mode 100644
index 000000000..4e9a72247
--- /dev/null
+++ b/test/profiling/convertHermesProfile.test.ts
@@ -0,0 +1,205 @@
+import type { ThreadCpuProfile, ThreadCpuSample } from '@sentry/types';
+
+import { convertToSentryProfile, mapSamples } from '../../src/js/profiling/convertHermesProfile';
+import type * as Hermes from '../../src/js/profiling/hermes';
+
+describe('convert hermes profile to sentry profile', () => {
+  it('simple test profile', async () => {
+    const hermesProfile: Hermes.Profile = {
+      traceEvents: [],
+      samples: [
+        {
+          cpu: '-1',
+          name: '',
+          ts: '10',
+          pid: 54822,
+          tid: '14509472',
+          weight: '1',
+          sf: 4,
+        },
+        {
+          cpu: '-1',
+          name: '',
+          ts: '20',
+          pid: 54822,
+          tid: '14509472',
+          weight: '1',
+          sf: 4,
+        },
+        {
+          cpu: '-1',
+          name: '',
+          ts: '30',
+          pid: 54822,
+          tid: '14509472',
+          weight: '1',
+          sf: 1,
+        },
+        {
+          cpu: '-1',
+          name: '',
+          ts: '40',
+          pid: 54822,
+          tid: '14509472',
+          weight: '1',
+          sf: 3,
+        },
+      ],
+      stackFrames: {
+        1: {
+          name: '[root]',
+          category: 'root',
+        },
+        2: {
+          line: '1610',
+          column: '33',
+          funcLine: '1605',
+          funcColumn: '14',
+          name: 'fooA(/absolute/path/app:///main.jsbundle:1610:33)',
+          category: 'JavaScript',
+          parent: 1,
+        },
+        3: {
+          line: '1616',
+          column: '21',
+          funcLine: '1614',
+          funcColumn: '14',
+          name: 'fooB(/absolute/path/app:///main.jsbundle:1616:21)',
+          category: 'JavaScript',
+          parent: 1,
+        },
+        4: {
+          line: '1627',
+          column: '18',
+          funcLine: '1623',
+          funcColumn: '16',
+          name: '(/absolute/path/app:///main.jsbundle:1627:18)',
+          category: 'JavaScript',
+          parent: 2,
+        },
+      },
+    };
+    const expectedSentryProfile: ThreadCpuProfile = {
+      frames: [
+        {
+          column: undefined,
+          file: undefined,
+          function: '[root]',
+          line: undefined,
+        },
+        {
+          column: 33,
+          file: 'app:///main.jsbundle',
+          function: 'fooA',
+          line: 1610,
+        },
+        {
+          column: 21,
+          file: 'app:///main.jsbundle',
+          function: 'fooB',
+          line: 1616,
+        },
+        {
+          column: 18,
+          file: 'app:///main.jsbundle',
+          function: 'anonymous',
+          line: 1627,
+        },
+      ],
+      samples: [
+        {
+          elapsed_since_start_ns: '0',
+          stack_id: 0,
+          thread_id: '14509472',
+        },
+        {
+          elapsed_since_start_ns: '10000',
+          stack_id: 0,
+          thread_id: '14509472',
+        },
+        {
+          elapsed_since_start_ns: '20000',
+          stack_id: 1,
+          thread_id: '14509472',
+        },
+        {
+          elapsed_since_start_ns: '30000',
+          stack_id: 2,
+          thread_id: '14509472',
+        },
+      ],
+      stacks: [[3, 1, 0], [0], [2, 0]],
+      thread_metadata: {
+        '14509472': {
+          name: 'JavaScriptThread',
+          priority: 1,
+        },
+      },
+    };
+    expect(convertToSentryProfile(hermesProfile)).toStrictEqual(expectedSentryProfile);
+  });
+
+  describe('converts profile samples', () => {
+    it('removes samples that are over the max duration of profile', () => {
+      const TEST_MAX_PROFILE_DURATION = 1000;
+      const hermesSamples: Hermes.Sample[] = [
+        {
+          ...getMinimumHermesSample(),
+          ts: '1',
+        },
+        {
+          ...getMinimumHermesSample(),
+          ts: '3',
+        },
+      ];
+      const expectedSentrySamples: ThreadCpuSample[] = [
+        {
+          ...getMinimumSentrySample(),
+          elapsed_since_start_ns: '0',
+        },
+      ];
+      expect(mapSamples(hermesSamples, TEST_MAX_PROFILE_DURATION).samples).toStrictEqual(expectedSentrySamples);
+    });
+
+    it('removes samples that are equal the max duration of profile', () => {
+      const TEST_MAX_PROFILE_DURATION = 1000;
+      const hermesSamples: Hermes.Sample[] = [
+        {
+          ...getMinimumHermesSample(),
+          ts: '1',
+        },
+        {
+          ...getMinimumHermesSample(),
+          ts: '2',
+        },
+      ];
+      const expectedSentrySamples: ThreadCpuSample[] = [
+        {
+          ...getMinimumSentrySample(),
+          elapsed_since_start_ns: '0',
+        },
+      ];
+      expect(mapSamples(hermesSamples, TEST_MAX_PROFILE_DURATION).samples).toStrictEqual(expectedSentrySamples);
+    });
+
+    function getMinimumHermesSample(): Hermes.Sample {
+      return {
+        cpu: '-1',
+        name: '',
+        ts: '1',
+        pid: 54822,
+        tid: '14509472',
+        weight: '1',
+        sf: 4,
+      };
+    }
+
+    function getMinimumSentrySample(): ThreadCpuSample {
+      return {
+        elapsed_since_start_ns: '0',
+        stack_id: 4,
+        thread_id: '14509472',
+      };
+    }
+  });
+});
diff --git a/test/profiling/hermes.test.ts b/test/profiling/hermes.test.ts
new file mode 100644
index 000000000..f9fb9a6b4
--- /dev/null
+++ b/test/profiling/hermes.test.ts
@@ -0,0 +1,18 @@
+import { parseHermesStackFrameFunctionName } from '../../src/js/profiling/hermes';
+
+describe('hermes', () => {
+  describe('parseHermesStackFrameName', () => {
+    test('parses function name and file name', () => {
+      expect(parseHermesStackFrameFunctionName('fooA(/absolute/path/main.jsbundle:1610:33)')).toEqual('fooA');
+    });
+    test('parse hermes root stack frame', () => {
+      expect(parseHermesStackFrameFunctionName('[root]')).toEqual('[root]');
+    });
+    test('parse only file name', () => {
+      expect(parseHermesStackFrameFunctionName('(/absolute/path/jsbundle:1610:33)')).toEqual('');
+    });
+    test('parse only function name', () => {
+      expect(parseHermesStackFrameFunctionName('fooA')).toEqual('fooA');
+    });
+  });
+});
diff --git a/test/profiling/integration.test.ts b/test/profiling/integration.test.ts
new file mode 100644
index 000000000..5fc83df27
--- /dev/null
+++ b/test/profiling/integration.test.ts
@@ -0,0 +1,255 @@
+import * as mockWrapper from '../mockWrapper';
+jest.mock('../../src/js/wrapper', () => mockWrapper);
+jest.mock('../../src/js/utils/environment');
+
+import type { Envelope, Event, Profile, Transaction, Transport } from '@sentry/types';
+
+import * as Sentry from '../../src/js';
+import { HermesProfiling } from '../../src/js/integrations';
+import type * as Hermes from '../../src/js/profiling/hermes';
+import { isHermesEnabled } from '../../src/js/utils/environment';
+import { RN_GLOBAL_OBJ } from '../../src/js/utils/worldwide';
+import { MOCK_DSN } from '../mockDsn';
+import { envelopeItemPayload, envelopeItems } from '../testutils';
+
+const SEC_TO_MS = 1e6;
+
+describe('profiling integration', () => {
+  let mock: {
+    transportSendMock: jest.Mock<ReturnType<Transport['send']>, Parameters<Transport['send']>>;
+  };
+
+  beforeEach(() => {
+    (isHermesEnabled as jest.Mock).mockReturnValue(true);
+    mockWrapper.NATIVE.startProfiling.mockReturnValue(true);
+    mockWrapper.NATIVE.stopProfiling.mockReturnValue(createMockMinimalValidHermesProfile());
+    jest.useFakeTimers();
+    mock = initTestClient();
+    jest.runAllTimers();
+    jest.clearAllMocks();
+  });
+
+  afterEach(async () => {
+    jest.runAllTimers();
+    jest.useRealTimers();
+    RN_GLOBAL_OBJ.__SENTRY__.globalEventProcessors = []; // resets integrations
+    await Sentry.close();
+  });
+
+  test('should create a new profile and add in to the transaction envelope', () => {
+    const transaction: Transaction = Sentry.startTransaction({
+      name: 'test-name',
+    });
+    transaction.finish();
+
+    jest.runAllTimers();
+
+    const envelope: Envelope | undefined = mock.transportSendMock.mock.lastCall?.[0];
+    const transactionEnvelopeItemPayload = envelope?.[envelopeItems][0][envelopeItemPayload] as Event;
+    const profileEnvelopeItem = envelope?.[envelopeItems][1] as [{ type: 'profile' }, Profile];
+    expect(profileEnvelopeItem).toEqual([
+      { type: 'profile' },
+      expect.objectContaining<Partial<Profile>>({
+        event_id: expect.any(String),
+        transaction: expect.objectContaining({
+          name: 'test-name',
+          id: transactionEnvelopeItemPayload.event_id,
+          trace_id: transaction.traceId,
+        }),
+      }),
+    ]);
+  });
+
+  test('should finish previous profile when a new transaction starts', () => {
+    const transaction1: Transaction = Sentry.startTransaction({
+      name: 'test-name-1',
+    });
+    const transaction2: Transaction = Sentry.startTransaction({
+      name: 'test-name-2',
+    });
+    transaction1.finish();
+    transaction2.finish();
+
+    jest.runAllTimers();
+
+    const envelopeTransaction1: Envelope | undefined = mock.transportSendMock.mock.calls[0][0];
+    const transaction1EnvelopeItemPayload = envelopeTransaction1?.[envelopeItems][0][envelopeItemPayload] as Event;
+    const profile1EnvelopeItem = envelopeTransaction1?.[envelopeItems][1] as [{ type: 'profile' }, Profile] | undefined;
+
+    const envelopeTransaction2: Envelope | undefined = mock.transportSendMock.mock.calls[1][0];
+    const transaction2EnvelopeItemPayload = envelopeTransaction2?.[envelopeItems][0][envelopeItemPayload] as Event;
+    const profile2EnvelopeItem = envelopeTransaction2?.[envelopeItems][1] as [{ type: 'profile' }, Profile] | undefined;
+
+    expect(profile1EnvelopeItem).toEqual([
+      { type: 'profile' },
+      expect.objectContaining<Partial<Profile>>({
+        event_id: expect.any(String),
+        transaction: expect.objectContaining({
+          name: 'test-name-1',
+          id: transaction1EnvelopeItemPayload.event_id,
+          trace_id: transaction1.traceId,
+        }),
+      }),
+    ]);
+    expect(profile2EnvelopeItem).toEqual([
+      { type: 'profile' },
+      expect.objectContaining<Partial<Profile>>({
+        event_id: expect.any(String),
+        transaction: expect.objectContaining({
+          name: 'test-name-2',
+          id: transaction2EnvelopeItemPayload.event_id,
+          trace_id: transaction2.traceId,
+        }),
+      }),
+    ]);
+  });
+
+  test('profile should start at the same time as transaction', () => {
+    const transaction: Transaction = Sentry.startTransaction({
+      name: 'test-name',
+    });
+    transaction.finish();
+
+    jest.runAllTimers();
+
+    const envelope: Envelope | undefined = mock.transportSendMock.mock.lastCall?.[0];
+    const transactionEnvelopeItemPayload = envelope?.[envelopeItems][0][envelopeItemPayload] as Event;
+    const profileEnvelopeItemPayload = envelope?.[envelopeItems][1][envelopeItemPayload] as unknown as Profile;
+    const transactionStart = Math.floor(transactionEnvelopeItemPayload.start_timestamp! * SEC_TO_MS);
+    const profileStart = new Date(profileEnvelopeItemPayload.timestamp).getTime();
+    expect(profileStart - transactionStart).toBeLessThan(10);
+  });
+
+  test('profile is only recorded until max duration is reached', () => {
+    const transaction: Transaction = Sentry.startTransaction({
+      name: 'test-name',
+    });
+    jest.clearAllMocks();
+
+    jest.advanceTimersByTime(40 * 1e6);
+
+    expect(mockWrapper.NATIVE.stopProfiling.mock.calls.length).toEqual(1);
+
+    transaction.finish();
+  });
+
+  test('profile that reached max duration is sent', () => {
+    const transaction: Transaction = Sentry.startTransaction({
+      name: 'test-name',
+    });
+
+    jest.advanceTimersByTime(40 * 1e6);
+
+    transaction.finish();
+
+    jest.runAllTimers();
+
+    const envelope: Envelope | undefined = mock.transportSendMock.mock.lastCall?.[0];
+    const transactionEnvelopeItemPayload = envelope?.[envelopeItems][0][envelopeItemPayload] as Event;
+    const profileEnvelopeItem = envelope?.[envelopeItems][1] as [{ type: 'profile' }, Profile];
+    expect(profileEnvelopeItem).toEqual([
+      { type: 'profile' },
+      expect.objectContaining<Partial<Profile>>({
+        event_id: expect.any(String),
+        transaction: expect.objectContaining({
+          name: 'test-name',
+          id: transactionEnvelopeItemPayload.event_id,
+          trace_id: transaction.traceId,
+        }),
+      }),
+    ]);
+  });
+
+  test('profile timeout is reset when transaction is finished', () => {
+    const integration = getCurrentHermesProfilingIntegration();
+    const transaction: Transaction = Sentry.startTransaction({
+      name: 'test-name',
+    });
+    const timeoutAfterProfileStarted = integration._currentProfileTimeout;
+
+    jest.advanceTimersByTime(40 * 1e6);
+
+    transaction.finish();
+    const timeoutAfterProfileFinished = integration._currentProfileTimeout;
+
+    jest.runAllTimers();
+
+    expect(timeoutAfterProfileStarted).toBeDefined();
+    expect(timeoutAfterProfileFinished).toBeUndefined();
+  });
+});
+
+type TestHermesIntegration = Omit<HermesProfiling, '_currentProfileTimeout'> & {
+  _currentProfileTimeout: number | undefined;
+};
+function getCurrentHermesProfilingIntegration(): TestHermesIntegration {
+  const integration = Sentry.getCurrentHub().getClient()?.getIntegration(HermesProfiling);
+  if (!integration) {
+    throw new Error('HermesProfiling integration is not installed');
+  }
+  return integration as unknown as TestHermesIntegration;
+}
+
+function initTestClient(): {
+  transportSendMock: jest.Mock<ReturnType<Transport['send']>, Parameters<Transport['send']>>;
+} {
+  const transportSendMock = jest.fn<ReturnType<Transport['send']>, Parameters<Transport['send']>>();
+  Sentry.init({
+    dsn: MOCK_DSN,
+    _experiments: {
+      profilesSampleRate: 1,
+    },
+    transport: () => ({
+      send: transportSendMock.mockResolvedValue(undefined),
+      flush: jest.fn().mockResolvedValue(true),
+    }),
+  });
+
+  // In production integrations are setup only once, but in the tests we want them to setup on every init
+  const integrations = Sentry.getCurrentHub().getClient()?.getOptions().integrations;
+  if (integrations) {
+    for (const integration of integrations) {
+      integration.setupOnce(Sentry.addGlobalEventProcessor, Sentry.getCurrentHub);
+    }
+  }
+
+  return {
+    transportSendMock,
+  };
+}
+
+/**
+ * Creates a mock Hermes profile that is valid enough to be added to an envelope.
+ * Min 2 samples are required by Sentry to be valid.
+ */
+function createMockMinimalValidHermesProfile(): Hermes.Profile {
+  return {
+    samples: [
+      {
+        cpu: '-1',
+        name: '',
+        ts: '10',
+        pid: 54822,
+        tid: '14509472',
+        weight: '1',
+        sf: 1,
+      },
+      {
+        cpu: '-1',
+        name: '',
+        ts: '20',
+        pid: 54822,
+        tid: '14509472',
+        weight: '1',
+        sf: 1,
+      },
+    ],
+    stackFrames: {
+      1: {
+        name: '[root]',
+        category: 'root',
+      },
+    },
+    traceEvents: [],
+  };
+}
diff --git a/test/sdk.test.ts b/test/sdk.test.ts
index 16b2acfa1..69abfbd1e 100644
--- a/test/sdk.test.ts
+++ b/test/sdk.test.ts
@@ -479,6 +479,30 @@ describe('Tests the SDK functionality', () => {
       expect(actualIntegrations).toEqual(expect.arrayContaining([expect.objectContaining({ name: 'ViewHierarchy' })]));
     });
 
+    it('no profiling integration by default', () => {
+      init({});
+
+      const actualOptions = mockedInitAndBind.mock.calls[0][secondArg] as ReactNativeClientOptions;
+      const actualIntegrations = actualOptions.integrations;
+      expect(actualIntegrations).toEqual(
+        expect.not.arrayContaining([expect.objectContaining({ name: 'HermesProfiling' })]),
+      );
+    });
+
+    it('adds profiling integration', () => {
+      init({
+        _experiments: {
+          profilesSampleRate: 0.7,
+        },
+      });
+
+      const actualOptions = mockedInitAndBind.mock.calls[0][secondArg] as ReactNativeClientOptions;
+      const actualIntegrations = actualOptions.integrations;
+      expect(actualIntegrations).toEqual(
+        expect.arrayContaining([expect.objectContaining({ name: 'HermesProfiling' })]),
+      );
+    });
+
     it('no default integrations', () => {
       init({
         defaultIntegrations: false,
diff --git a/test/testutils.ts b/test/testutils.ts
index 49e7dd0b1..5e2ec0f68 100644
--- a/test/testutils.ts
+++ b/test/testutils.ts
@@ -4,6 +4,10 @@ import { rejectedSyncPromise } from '@sentry/utils';
 
 import { getBlankTransactionContext } from '../src/js/tracing/utils';
 
+export type MockInterface<T> = {
+  [K in keyof T]: T[K] extends (...args: infer A) => infer B ? jest.Mock<B, A> : T[K];
+} & T;
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function mockFunction<T extends (...args: any[]) => any>(fn: T): jest.MockedFunction<T> {
   return fn as jest.MockedFunction<T>;
diff --git a/test/wrapper.test.ts b/test/wrapper.test.ts
index 11bb81d3a..ac3221fc5 100644
--- a/test/wrapper.test.ts
+++ b/test/wrapper.test.ts
@@ -46,6 +46,8 @@ jest.mock(
       closeNativeSdk: jest.fn(() => Promise.resolve()),
       // @ts-ignore for testing.
       _getLastPayload: () => ({ initPayload }),
+      startProfiling: jest.fn(),
+      stopProfiling: jest.fn(),
     };
 
     return {
@@ -560,4 +562,37 @@ describe('Tests Native Wrapper', () => {
       expect(NATIVE.enableNative).toBe(false);
     });
   });
+
+  describe('profiling', () => {
+    test('start profiling returns true', () => {
+      (RNSentry.startProfiling as jest.MockedFunction<typeof RNSentry.startProfiling>).mockReturnValue({
+        started: true,
+      });
+      expect(NATIVE.startProfiling()).toBe(true);
+    });
+    test('failed start profiling returns false', () => {
+      (RNSentry.startProfiling as jest.MockedFunction<typeof RNSentry.startProfiling>).mockReturnValue({
+        error: 'error',
+      });
+      expect(NATIVE.startProfiling()).toBe(false);
+    });
+    test('stop profiling returns profile', () => {
+      (RNSentry.stopProfiling as jest.MockedFunction<typeof RNSentry.stopProfiling>).mockReturnValue({
+        profile: '{ "valid": "json" }',
+      });
+      expect(NATIVE.stopProfiling()).toEqual({ valid: 'json' });
+    });
+    test('failed stop profiling returns null', () => {
+      (RNSentry.stopProfiling as jest.MockedFunction<typeof RNSentry.stopProfiling>).mockReturnValue({
+        error: 'error',
+      });
+      expect(NATIVE.stopProfiling()).toBe(null);
+    });
+    test('stop profiling returns null on invalid json profile', () => {
+      (RNSentry.stopProfiling as jest.MockedFunction<typeof RNSentry.stopProfiling>).mockReturnValue({
+        profile: 'invalid',
+      });
+      expect(NATIVE.stopProfiling()).toBe(null);
+    });
+  });
 });