diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8cb55637577..6c784e090b4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,10 @@
 - Prevent concurrent PixelCopy access during Session Replay masking and bitmap cleanup ([#5808](https://github.com/getsentry/sentry-java/pull/5808))
 - Release `MediaMuxer` when the replay video encoder fails to start to avoid a resource leak ([#5607](https://github.com/getsentry/sentry-java/pull/5607))
 
+### Features
+
+- Added `Environment` to the `Scope`, allowing you to overwrite the `Environment` set on the options ([#5772](https://github.com/getsentry/sentry-java/pull/5772))
+
 ### Performance
 
 - Reduce the number of SDK threads: `LifecycleWatcher` now schedules the session-end task on the shared timer executor instead of creating a dedicated `java.util.Timer` thread ([#5819](https://github.com/getsentry/sentry-java/pull/5819))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
index f175db90488..d08d0ec1f10 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
@@ -196,6 +196,7 @@ private void backfillScope(
     setRequest(event);
     setUser(event);
     setScopeTags(event);
+    setScopeEnvironment(event);
     setBreadcrumbs(event);
     setExtras(event);
     setContexts(event);
@@ -487,6 +488,16 @@ private void setEnvironment(
     }
   }
 
+  private void setScopeEnvironment(final @NotNull SentryBaseEvent event) {
+    if (event.getEnvironment() == null) {
+      final @Nullable String scopeEnvironment =
+          readFromDisk(options, PersistingScopeObserver.ENVIRONMENT_FILENAME, String.class);
+      if (scopeEnvironment != null) {
+        event.setEnvironment(scopeEnvironment);
+      }
+    }
+  }
+
   private void setDebugMeta(
       final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     DebugMeta debugMeta = event.getDebugMeta();
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
index d5b916d3b44..e8aebffec9b 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
@@ -401,6 +401,18 @@ class ApplicationExitInfoEventProcessorTest {
     assertEquals("release", processed.environment)
   }
 
+  @Test
+  fun `if scope environment is persisted, it takes precedence over the options environment`() {
+    val hint = HintUtils.createWithTypeCheckHint(BackfillableHint())
+
+    val processor = fixture.getSut(tmpDir, populateOptionsCache = true)
+    fixture.persistScope(PersistingScopeObserver.ENVIRONMENT_FILENAME, "staging")
+
+    val processed = processor.process(SentryEvent(), hint)
+
+    assertEquals("staging", processed!!.environment)
+  }
+
   @Test
   fun `if release is not persisted and app was not updated, uses release from options`() {
     val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 2_000))
@@ -482,6 +494,7 @@ class ApplicationExitInfoEventProcessorTest {
     fixture.options.release = "io.sentry.samples@1.2.0+232"
     fixture.options.environment = "production"
     fixture.options.dist = "custom-dist"
+    fixture.persistScope(PersistingScopeObserver.ENVIRONMENT_FILENAME, "staging")
     setLastUpdateTime(1_000)
 
     val processed = processor.process(SentryEvent(), hint)!!
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index c623e71d08f..d86a42ca46c 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -286,6 +286,7 @@ public final class io/sentry/CombinedScopeView : io/sentry/IScope {
 	public fun getBreadcrumbs ()Ljava/util/Queue;
 	public fun getClient ()Lio/sentry/ISentryClient;
 	public fun getContexts ()Lio/sentry/protocol/Contexts;
+	public fun getEnvironment ()Ljava/lang/String;
 	public fun getEventProcessors ()Ljava/util/List;
 	public fun getEventProcessorsWithOrder ()Ljava/util/List;
 	public fun getExtras ()Ljava/util/Map;
@@ -321,6 +322,7 @@ public final class io/sentry/CombinedScopeView : io/sentry/IScope {
 	public fun setContexts (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setContexts (Ljava/lang/String;Ljava/util/Collection;)V
 	public fun setContexts (Ljava/lang/String;[Ljava/lang/Object;)V
+	public fun setEnvironment (Ljava/lang/String;)V
 	public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setFingerprint (Ljava/util/List;)V
 	public fun setLastEventId (Lio/sentry/protocol/SentryId;)V
@@ -922,6 +924,7 @@ public abstract interface class io/sentry/IScope {
 	public abstract fun getBreadcrumbs ()Ljava/util/Queue;
 	public abstract fun getClient ()Lio/sentry/ISentryClient;
 	public abstract fun getContexts ()Lio/sentry/protocol/Contexts;
+	public abstract fun getEnvironment ()Ljava/lang/String;
 	public abstract fun getEventProcessors ()Ljava/util/List;
 	public abstract fun getEventProcessorsWithOrder ()Ljava/util/List;
 	public abstract fun getExtras ()Ljava/util/Map;
@@ -957,6 +960,7 @@ public abstract interface class io/sentry/IScope {
 	public abstract fun setContexts (Ljava/lang/String;Ljava/lang/String;)V
 	public abstract fun setContexts (Ljava/lang/String;Ljava/util/Collection;)V
 	public abstract fun setContexts (Ljava/lang/String;[Ljava/lang/Object;)V
+	public abstract fun setEnvironment (Ljava/lang/String;)V
 	public abstract fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public abstract fun setFingerprint (Ljava/util/List;)V
 	public abstract fun setLastEventId (Lio/sentry/protocol/SentryId;)V
@@ -984,6 +988,7 @@ public abstract interface class io/sentry/IScopeObserver {
 	public abstract fun removeTag (Ljava/lang/String;)V
 	public abstract fun setBreadcrumbs (Ljava/util/Collection;)V
 	public abstract fun setContexts (Lio/sentry/protocol/Contexts;)V
+	public abstract fun setEnvironment (Ljava/lang/String;)V
 	public abstract fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public abstract fun setExtras (Ljava/util/Map;)V
 	public abstract fun setFingerprint (Ljava/util/Collection;)V
@@ -1745,6 +1750,7 @@ public final class io/sentry/NoOpScope : io/sentry/IScope {
 	public fun getBreadcrumbs ()Ljava/util/Queue;
 	public fun getClient ()Lio/sentry/ISentryClient;
 	public fun getContexts ()Lio/sentry/protocol/Contexts;
+	public fun getEnvironment ()Ljava/lang/String;
 	public fun getEventProcessors ()Ljava/util/List;
 	public fun getEventProcessorsWithOrder ()Ljava/util/List;
 	public fun getExtras ()Ljava/util/Map;
@@ -1781,6 +1787,7 @@ public final class io/sentry/NoOpScope : io/sentry/IScope {
 	public fun setContexts (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setContexts (Ljava/lang/String;Ljava/util/Collection;)V
 	public fun setContexts (Ljava/lang/String;[Ljava/lang/Object;)V
+	public fun setEnvironment (Ljava/lang/String;)V
 	public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setFingerprint (Ljava/util/List;)V
 	public fun setLastEventId (Lio/sentry/protocol/SentryId;)V
@@ -2434,6 +2441,7 @@ public final class io/sentry/Scope : io/sentry/IScope {
 	public fun getBreadcrumbs ()Ljava/util/Queue;
 	public fun getClient ()Lio/sentry/ISentryClient;
 	public fun getContexts ()Lio/sentry/protocol/Contexts;
+	public fun getEnvironment ()Ljava/lang/String;
 	public fun getEventProcessors ()Ljava/util/List;
 	public fun getEventProcessorsWithOrder ()Ljava/util/List;
 	public fun getExtras ()Ljava/util/Map;
@@ -2469,6 +2477,7 @@ public final class io/sentry/Scope : io/sentry/IScope {
 	public fun setContexts (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setContexts (Ljava/lang/String;Ljava/util/Collection;)V
 	public fun setContexts (Ljava/lang/String;[Ljava/lang/Object;)V
+	public fun setEnvironment (Ljava/lang/String;)V
 	public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setFingerprint (Ljava/util/List;)V
 	public fun setLastEventId (Lio/sentry/protocol/SentryId;)V
@@ -2517,6 +2526,7 @@ public abstract class io/sentry/ScopeObserverAdapter : io/sentry/IScopeObserver
 	public fun removeTag (Ljava/lang/String;)V
 	public fun setBreadcrumbs (Ljava/util/Collection;)V
 	public fun setContexts (Lio/sentry/protocol/Contexts;)V
+	public fun setEnvironment (Ljava/lang/String;)V
 	public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setExtras (Ljava/util/Map;)V
 	public fun setFingerprint (Ljava/util/Collection;)V
@@ -4880,6 +4890,7 @@ public final class io/sentry/cache/PersistingOptionsObserver : io/sentry/IOption
 public final class io/sentry/cache/PersistingScopeObserver : io/sentry/ScopeObserverAdapter {
 	public static final field BREADCRUMBS_FILENAME Ljava/lang/String;
 	public static final field CONTEXTS_FILENAME Ljava/lang/String;
+	public static final field ENVIRONMENT_FILENAME Ljava/lang/String;
 	public static final field EXTRAS_FILENAME Ljava/lang/String;
 	public static final field FINGERPRINT_FILENAME Ljava/lang/String;
 	public static final field LEVEL_FILENAME Ljava/lang/String;
@@ -4896,6 +4907,7 @@ public final class io/sentry/cache/PersistingScopeObserver : io/sentry/ScopeObse
 	public fun resetCache ()V
 	public fun setBreadcrumbs (Ljava/util/Collection;)V
 	public fun setContexts (Lio/sentry/protocol/Contexts;)V
+	public fun setEnvironment (Ljava/lang/String;)V
 	public fun setExtras (Ljava/util/Map;)V
 	public fun setFingerprint (Ljava/util/Collection;)V
 	public fun setLevel (Lio/sentry/SentryLevel;)V
diff --git a/sentry/src/main/java/io/sentry/CombinedScopeView.java b/sentry/src/main/java/io/sentry/CombinedScopeView.java
index ea2d752d44b..cb2ff8c6401 100644
--- a/sentry/src/main/java/io/sentry/CombinedScopeView.java
+++ b/sentry/src/main/java/io/sentry/CombinedScopeView.java
@@ -56,6 +56,24 @@ public void setLevel(@Nullable SentryLevel level) {
     getDefaultWriteScope().setLevel(level);
   }
 
+  @Override
+  public @Nullable String getEnvironment() {
+    final @Nullable String current = scope.getEnvironment();
+    if (current != null) {
+      return current;
+    }
+    final @Nullable String isolation = isolationScope.getEnvironment();
+    if (isolation != null) {
+      return isolation;
+    }
+    return globalScope.getEnvironment();
+  }
+
+  @Override
+  public void setEnvironment(@Nullable String environment) {
+    getDefaultWriteScope().setEnvironment(environment);
+  }
+
   @Override
   public @Nullable String getTransactionName() {
     final @Nullable String current = scope.getTransactionName();
@@ -540,7 +558,11 @@ public void addEventProcessor(@NotNull EventProcessor eventProcessor) {
 
   @Override
   public @Nullable Scope.SessionPair startSession() {
-    return getDefaultWriteScope().startSession();
+    final IScope defaultScope = getDefaultWriteScope();
+    if (defaultScope instanceof Scope) {
+      return ((Scope) defaultScope).startSession(getEnvironment());
+    }
+    return defaultScope.startSession();
   }
 
   @Override
diff --git a/sentry/src/main/java/io/sentry/IScope.java b/sentry/src/main/java/io/sentry/IScope.java
index 5b6c38bbcfb..ee512c7441f 100644
--- a/sentry/src/main/java/io/sentry/IScope.java
+++ b/sentry/src/main/java/io/sentry/IScope.java
@@ -26,6 +26,21 @@ public interface IScope {
    */
   void setLevel(final @Nullable SentryLevel level);
 
+  /**
+   * Returns the Scope's environment.
+   *
+   * @return the environment or {@code null} if not set on the scope
+   */
+  @Nullable
+  String getEnvironment();
+
+  /**
+   * Sets the Scope's environment. Takes precedence over {@link SentryOptions#getEnvironment()}.
+   *
+   * @param environment the environment
+   */
+  void setEnvironment(final @Nullable String environment);
+
   /**
    * Returns the Scope's transaction name.
    *
diff --git a/sentry/src/main/java/io/sentry/IScopeObserver.java b/sentry/src/main/java/io/sentry/IScopeObserver.java
index e1b9a785043..b6210c88701 100644
--- a/sentry/src/main/java/io/sentry/IScopeObserver.java
+++ b/sentry/src/main/java/io/sentry/IScopeObserver.java
@@ -38,6 +38,8 @@ public interface IScopeObserver {
 
   void setLevel(@Nullable SentryLevel level);
 
+  void setEnvironment(@Nullable String environment);
+
   void setContexts(@NotNull Contexts contexts);
 
   void setTransaction(@Nullable String transaction);
diff --git a/sentry/src/main/java/io/sentry/NoOpScope.java b/sentry/src/main/java/io/sentry/NoOpScope.java
index 9d2f603c673..a452cb3f350 100644
--- a/sentry/src/main/java/io/sentry/NoOpScope.java
+++ b/sentry/src/main/java/io/sentry/NoOpScope.java
@@ -41,6 +41,14 @@ public static NoOpScope getInstance() {
   @Override
   public void setLevel(@Nullable SentryLevel level) {}
 
+  @Override
+  public @Nullable String getEnvironment() {
+    return null;
+  }
+
+  @Override
+  public void setEnvironment(@Nullable String environment) {}
+
   @Override
   public @Nullable String getTransactionName() {
     return null;
diff --git a/sentry/src/main/java/io/sentry/Scope.java b/sentry/src/main/java/io/sentry/Scope.java
index 195e5b5b05a..95dec3e85b0 100644
--- a/sentry/src/main/java/io/sentry/Scope.java
+++ b/sentry/src/main/java/io/sentry/Scope.java
@@ -54,6 +54,9 @@ public final class Scope implements IScope {
   /** Scope's screen */
   private @Nullable String screen;
 
+  /** Scope's environment */
+  private @Nullable String environment;
+
   /** Scope's request */
   private @Nullable Request request;
 
@@ -138,6 +141,7 @@ private Scope(final @NotNull Scope scope) {
     final User userRef = scope.user;
     this.user = userRef != null ? new User(userRef) : null;
     this.screen = scope.screen;
+    this.environment = scope.environment;
     this.replayId = scope.replayId;
 
     final Request requestRef = scope.request;
@@ -225,6 +229,30 @@ public void setLevel(final @Nullable SentryLevel level) {
     }
   }
 
+  /**
+   * Returns the Scope's environment.
+   *
+   * @return the environment or {@code null} if not set on the scope
+   */
+  @Override
+  public @Nullable String getEnvironment() {
+    return environment;
+  }
+
+  /**
+   * Sets the Scope's environment. Takes precedence over {@link SentryOptions#getEnvironment()}.
+   *
+   * @param environment the environment
+   */
+  @Override
+  public void setEnvironment(final @Nullable String environment) {
+    this.environment = environment;
+
+    for (final IScopeObserver observer : options.getScopeObservers()) {
+      observer.setEnvironment(environment);
+    }
+  }
+
   /**
    * Returns the Scope's transaction name.
    *
@@ -566,7 +594,8 @@ public ITransaction getTransaction() {
   /** Resets the Scope to its default state */
   @Override
   public void clear() {
-    level = null;
+    setLevel(null);
+    setEnvironment(null);
     user = null;
     request = null;
     screen = null;
@@ -1032,6 +1061,11 @@ interface IWithSession {
   @Nullable
   @Override
   public SessionPair startSession() {
+    return startSession(environment);
+  }
+
+  @Nullable
+  SessionPair startSession(final @Nullable String sessionEnvironment) {
     Session previousSession;
     SessionPair pair = null;
     try (final @NotNull ISentryLifecycleToken ignored = sessionLock.acquire()) {
@@ -1046,7 +1080,10 @@ public SessionPair startSession() {
       if (options.getRelease() != null) {
         session =
             new Session(
-                options.getDistinctId(), user, options.getEnvironment(), options.getRelease());
+                options.getDistinctId(),
+                user,
+                sessionEnvironment != null ? sessionEnvironment : options.getEnvironment(),
+                options.getRelease());
 
         final Session previousClone = previousSession != null ? previousSession.clone() : null;
         pair = new SessionPair(session.clone(), previousClone);
diff --git a/sentry/src/main/java/io/sentry/ScopeObserverAdapter.java b/sentry/src/main/java/io/sentry/ScopeObserverAdapter.java
index 4f6a5ac842c..e80d8b6b208 100644
--- a/sentry/src/main/java/io/sentry/ScopeObserverAdapter.java
+++ b/sentry/src/main/java/io/sentry/ScopeObserverAdapter.java
@@ -46,6 +46,9 @@ public void setFingerprint(@NotNull Collection<String> fingerprint) {}
   @Override
   public void setLevel(@Nullable SentryLevel level) {}
 
+  @Override
+  public void setEnvironment(@Nullable String environment) {}
+
   @Override
   public void setContexts(@NotNull Contexts contexts) {}
 
diff --git a/sentry/src/main/java/io/sentry/Sentry.java b/sentry/src/main/java/io/sentry/Sentry.java
index 8bba9d92e4f..d9131f0c4f5 100644
--- a/sentry/src/main/java/io/sentry/Sentry.java
+++ b/sentry/src/main/java/io/sentry/Sentry.java
@@ -579,6 +579,10 @@ private static void notifyOptionsObservers(final @NotNull SentryOptions options)
                     options.findPersistingScopeObserver();
                 if (scopeCache != null) {
                   scopeCache.resetCache();
+                  final @Nullable String environment = globalScope.getEnvironment();
+                  if (environment != null) {
+                    scopeCache.setEnvironment(environment);
+                  }
                 }
               });
     } catch (Throwable e) {
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index a25aa9c79e1..2fa4531fc50 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -1156,6 +1156,10 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
       hint = new Hint();
     }
 
+    if (shouldApplyScopeData(checkIn, hint)) {
+      checkIn = applyScope(checkIn, scope);
+    }
+
     if (checkIn.getEnvironment() == null) {
       checkIn.setEnvironment(options.getEnvironment());
     }
@@ -1164,10 +1168,6 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
       checkIn.setRelease(options.getRelease());
     }
 
-    if (shouldApplyScopeData(checkIn, hint)) {
-      checkIn = applyScope(checkIn, scope);
-    }
-
     if (CheckInUtils.isIgnored(options.getIgnoredCheckIns(), checkIn.getMonitorSlug())) {
       options
           .getLogger()
@@ -1501,6 +1501,9 @@ public void captureBatchedMetricsEvents(final @NotNull SentryMetricsEvents metri
   private @Nullable SentryEvent applyFeedbackScope(
       @NotNull SentryEvent event, final @NotNull IScope scope, final @NotNull Hint hint) {
 
+    if (event.getEnvironment() == null) {
+      event.setEnvironment(scope.getEnvironment());
+    }
     if (event.getUser() == null) {
       event.setUser(scope.getUser());
     }
@@ -1537,6 +1540,9 @@ public void captureBatchedMetricsEvents(final @NotNull SentryMetricsEvents metri
 
   private @NotNull CheckIn applyScope(@NotNull CheckIn checkIn, final @Nullable IScope scope) {
     if (scope != null) {
+      if (checkIn.getEnvironment() == null) {
+        checkIn.setEnvironment(scope.getEnvironment());
+      }
       // Set trace data from active span to connect events with transactions
       final ISpan span = scope.getSpan();
       if (checkIn.getContexts().getTrace() == null) {
@@ -1562,6 +1568,9 @@ public void captureBatchedMetricsEvents(final @NotNull SentryMetricsEvents metri
       if (replayEvent.getUser() == null) {
         replayEvent.setUser(scope.getUser());
       }
+      if (replayEvent.getEnvironment() == null) {
+        replayEvent.setEnvironment(scope.getEnvironment());
+      }
       if (replayEvent.getTags() == null) {
         replayEvent.setTags(scope.getTags());
       } else {
@@ -1602,6 +1611,9 @@ public void captureBatchedMetricsEvents(final @NotNull SentryMetricsEvents metri
       if (sentryBaseEvent.getUser() == null) {
         sentryBaseEvent.setUser(scope.getUser());
       }
+      if (sentryBaseEvent.getEnvironment() == null) {
+        sentryBaseEvent.setEnvironment(scope.getEnvironment());
+      }
       if (sentryBaseEvent.getTags() == null) {
         sentryBaseEvent.setTags(scope.getTags());
       } else {
diff --git a/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java b/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
index 420d0d31e22..4dde96afcc2 100644
--- a/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
+++ b/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
@@ -46,6 +46,7 @@ public final class PersistingScopeObserver extends ScopeObserverAdapter {
   public static final String CONTEXTS_FILENAME = "contexts.json";
   public static final String REQUEST_FILENAME = "request.json";
   public static final String LEVEL_FILENAME = "level.json";
+  public static final String ENVIRONMENT_FILENAME = "environment.json";
   public static final String FINGERPRINT_FILENAME = "fingerprint.json";
   public static final String TRANSACTION_FILENAME = "transaction.json";
   public static final String TRACE_FILENAME = "trace.json";
@@ -189,6 +190,18 @@ public void setLevel(@Nullable SentryLevel level) {
         });
   }
 
+  @Override
+  public void setEnvironment(@Nullable String environment) {
+    serializeToDisk(
+        () -> {
+          if (environment == null) {
+            delete(ENVIRONMENT_FILENAME);
+          } else {
+            store(environment, ENVIRONMENT_FILENAME);
+          }
+        });
+  }
+
   @Override
   public void setTransaction(@Nullable String transaction) {
     serializeToDisk(
@@ -296,6 +309,7 @@ public void resetCache() {
     // the rest we can safely delete
     delete(USER_FILENAME);
     delete(LEVEL_FILENAME);
+    delete(ENVIRONMENT_FILENAME);
     delete(REQUEST_FILENAME);
     delete(FINGERPRINT_FILENAME);
     delete(CONTEXTS_FILENAME);
diff --git a/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt b/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt
index fd187235a92..9439306eec5 100644
--- a/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt
+++ b/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt
@@ -1115,6 +1115,17 @@ class CombinedScopeViewTest {
     assertNull(fixture.globalScope.session)
   }
 
+  @Test
+  fun `starts session with the combined environment`() {
+    val combined = fixture.getSut()
+    fixture.options.environment = "options-environment"
+    fixture.scope.environment = "current-environment"
+
+    combined.startSession()
+
+    assertEquals("current-environment", fixture.isolationScope.session!!.environment)
+  }
+
   @Test
   fun `ends session on default scope`() {
     val combined = fixture.getSut()
diff --git a/sentry/src/test/java/io/sentry/ScopeTest.kt b/sentry/src/test/java/io/sentry/ScopeTest.kt
index 7af4f6ccdca..3226bef585a 100644
--- a/sentry/src/test/java/io/sentry/ScopeTest.kt
+++ b/sentry/src/test/java/io/sentry/ScopeTest.kt
@@ -290,6 +290,7 @@ class ScopeTest {
     scope.addBreadcrumb(Breadcrumb())
     scope.setTag("some", "tag")
     scope.screen = "MainActivity"
+    scope.environment = "staging"
     scope.setExtra("some", "extra")
     scope.setAttribute("some", "attribute")
     scope.addEventProcessor(eventProcessor())
@@ -303,6 +304,7 @@ class ScopeTest {
     assertNull(scope.user)
     assertNull(scope.request)
     assertNull(scope.screen)
+    assertNull(scope.environment)
     assertEquals(0, scope.fingerprint.size)
     assertEquals(0, scope.breadcrumbs.size)
     assertEquals(0, scope.tags.size)
@@ -462,6 +464,21 @@ class ScopeTest {
     }
   }
 
+  @Test
+  fun `Scope starts a new session with scope environment`() {
+    val options =
+      SentryOptions().apply {
+        release = "rel"
+        environment = "options-env"
+      }
+    val scope = Scope(options)
+    scope.environment = "scope-env"
+
+    val sessionPair = scope.startSession()
+
+    assertNotNull(sessionPair) { assertEquals("scope-env", it.current.environment) }
+  }
+
   @Test
   fun `Scope ends a session and returns it if theres one`() {
     val options = SentryOptions().apply { release = "0.0.1" }
@@ -802,6 +819,47 @@ class ScopeTest {
     verify(observer).setLevel(eq(WARNING))
   }
 
+  @Test
+  fun `Scope clear level sync scopes`() {
+    val observer = mock<IScopeObserver>()
+    val options = SentryOptions().apply { addScopeObserver(observer) }
+    val scope = Scope(options)
+
+    scope.clear()
+
+    verify(observer).setLevel(null)
+  }
+
+  @Test
+  fun `Scope set environment sync scopes`() {
+    val observer = mock<IScopeObserver>()
+    val options = SentryOptions().apply { addScopeObserver(observer) }
+    val scope = Scope(options)
+
+    scope.environment = "staging"
+    verify(observer).setEnvironment(eq("staging"))
+  }
+
+  @Test
+  fun `Scope set environment null sync scopes`() {
+    val observer = mock<IScopeObserver>()
+    val options = SentryOptions().apply { addScopeObserver(observer) }
+    val scope = Scope(options)
+
+    scope.environment = null
+    verify(observer).setEnvironment(null)
+  }
+
+  @Test
+  fun `Scope clone copies environment`() {
+    val scope = Scope(SentryOptions())
+    scope.environment = "staging"
+
+    val clone = scope.clone()
+
+    assertEquals("staging", clone.environment)
+  }
+
   @Test
   fun `Scope set transaction name sync scopes`() {
     val observer = mock<IScopeObserver>()
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index fa37cb0b70b..6e9ede92298 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -680,24 +680,35 @@ class SentryClientTest {
   }
 
   @Test
-  fun `when event has environment, value from options not applied`() {
+  fun `when scope has environment, it takes precedence over options`() {
     val event = SentryEvent()
-    val expected = "original"
-    fixture.sentryOptions.environment = "not to be applied"
-    event.environment = expected
+    val scope = createScope()
+    scope.environment = "from-scope"
+    fixture.sentryOptions.environment = "from-options"
     val sut = fixture.getSut()
-    sut.captureEvent(event)
-    assertEquals(expected, event.environment)
+    sut.captureEvent(event, scope)
+    assertEquals("from-scope", event.environment)
   }
 
   @Test
-  fun `when event doesn't have environment, value from options applied`() {
+  fun `when event has environment, scope environment not applied`() {
     val event = SentryEvent()
-    val expected = "original"
-    fixture.sentryOptions.environment = expected
+    event.environment = "from-event"
+    val scope = createScope()
+    scope.environment = "from-scope"
     val sut = fixture.getSut()
-    sut.captureEvent(event)
-    assertEquals(expected, event.environment)
+    sut.captureEvent(event, scope)
+    assertEquals("from-event", event.environment)
+  }
+
+  @Test
+  fun `when scope has no environment, value from options applied`() {
+    val event = SentryEvent()
+    val scope = createScope()
+    fixture.sentryOptions.environment = "from-options"
+    val sut = fixture.getSut()
+    sut.captureEvent(event, scope)
+    assertEquals("from-options", event.environment)
   }
 
   @Test
@@ -1005,6 +1016,16 @@ class SentryClientTest {
       )
   }
 
+  @Test
+  fun `when captureCheckIn, scope environment takes precedence over options`() {
+    val scope = Scope(fixture.sentryOptions).apply { environment = "scope-environment" }
+    val sut = fixture.getSut { it.environment = "options-environment" }
+
+    sut.captureCheckIn(checkIn, scope, null)
+
+    assertEquals("scope-environment", checkIn.environment)
+  }
+
   @Test
   fun `when captureCheckIn, envelope is sent if ignored slug does not match`() {
     val sut = fixture.getSut { options -> options.setIgnoredCheckIns(listOf("non_matching_slug")) }
@@ -3743,6 +3764,21 @@ class SentryClientTest {
     assertTrue(invoked)
   }
 
+  @Test
+  fun `when captureReplayEvent, scope environment overrides options`() {
+    var capturedEnvironment: String? = null
+    fixture.sentryOptions.environment = "from-options"
+    fixture.sentryOptions.setBeforeSendReplay { replay: SentryReplayEvent, _: Hint ->
+      capturedEnvironment = replay.environment
+      replay
+    }
+    val scope = Scope(fixture.sentryOptions).apply { environment = "from-scope" }
+
+    fixture.getSut().captureReplayEvent(SentryReplayEvent(), scope, Hint())
+
+    assertEquals("from-scope", capturedEnvironment)
+  }
+
   @Test
   fun `when beforeSendReplay returns null, event is dropped`() {
     fixture.sentryOptions.setBeforeSendReplay { replay: SentryReplayEvent, _: Hint -> null }
@@ -3842,6 +3878,7 @@ class SentryClientTest {
     val scope = createScope()
     val scopeReplayId = SentryId()
     scope.contexts.setTrace(SpanContext("test"))
+    scope.environment = "scope-environment"
     scope.setContexts("context-key", "context-value")
     scope.screen = "screen"
     scope.replayId = scopeReplayId
@@ -3851,6 +3888,7 @@ class SentryClientTest {
     assertNotNull(sentFeedback)
     // User, tags and contexts are applied to the feedback
     assertEquals(scope.user, sentEvent!!.user)
+    assertEquals("scope-environment", sentEvent!!.environment)
     assertEquals("tags", sentEvent!!.tags!!["tags"])
     assertEquals(
       scope.contexts.trace!!.traceId.toString(),
diff --git a/sentry/src/test/java/io/sentry/SentryTest.kt b/sentry/src/test/java/io/sentry/SentryTest.kt
index 8d05697fda4..cd1c251f84b 100644
--- a/sentry/src/test/java/io/sentry/SentryTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryTest.kt
@@ -7,6 +7,7 @@ import io.sentry.backpressure.BackpressureMonitor
 import io.sentry.backpressure.NoOpBackpressureMonitor
 import io.sentry.cache.EnvelopeCache
 import io.sentry.cache.IEnvelopeCache
+import io.sentry.cache.PersistingScopeObserver
 import io.sentry.internal.debugmeta.IDebugMetaLoader
 import io.sentry.internal.debugmeta.ResourcesDebugMetaLoader
 import io.sentry.internal.modules.CompositeModulesLoader
@@ -173,6 +174,32 @@ class SentryTest {
     assertFalse(Sentry.getGlobalScope().client.isEnabled)
   }
 
+  @Test
+  fun `init persists pre-init global scope environment`() {
+    val options =
+      SentryOptions().apply {
+        dsn = this@SentryTest.dsn
+        cacheDirPath = getTempPath()
+        executorService = ImmediateExecutorService()
+        addScopeObserver(PersistingScopeObserver(this))
+      }
+    Sentry.getGlobalScope().environment = "pre-init-environment"
+
+    try {
+      initForTest(options)
+
+      assertEquals(
+        "pre-init-environment",
+        PersistingScopeObserver(options)
+          .read(options, PersistingScopeObserver.ENVIRONMENT_FILENAME, String::class.java),
+      )
+    } finally {
+      Sentry.close()
+      Sentry.getGlobalScope().replaceOptions(SentryOptions.empty())
+      Sentry.getGlobalScope().environment = null
+    }
+  }
+
   @Test
   fun `close calls scopes close with isRestarting false`() {
     val scopes = mock<IScopes>()
diff --git a/sentry/src/test/java/io/sentry/cache/PersistingScopeObserverTest.kt b/sentry/src/test/java/io/sentry/cache/PersistingScopeObserverTest.kt
index f682ac4c474..b98c5b8a319 100644
--- a/sentry/src/test/java/io/sentry/cache/PersistingScopeObserverTest.kt
+++ b/sentry/src/test/java/io/sentry/cache/PersistingScopeObserverTest.kt
@@ -9,6 +9,7 @@ import io.sentry.SpanContext
 import io.sentry.SpanId
 import io.sentry.cache.PersistingScopeObserver.BREADCRUMBS_FILENAME
 import io.sentry.cache.PersistingScopeObserver.CONTEXTS_FILENAME
+import io.sentry.cache.PersistingScopeObserver.ENVIRONMENT_FILENAME
 import io.sentry.cache.PersistingScopeObserver.EXTRAS_FILENAME
 import io.sentry.cache.PersistingScopeObserver.FINGERPRINT_FILENAME
 import io.sentry.cache.PersistingScopeObserver.LEVEL_FILENAME
@@ -196,6 +197,15 @@ class PersistingScopeObserverTest<T>(
         DeletedEntityProvider { null },
       )
 
+    private fun environment(): Array<Any?> =
+      arrayOf(
+        "staging",
+        StoreScopeValue<String> { environment, _ -> setEnvironment(environment) },
+        ENVIRONMENT_FILENAME,
+        DeleteScopeValue { setEnvironment(null) },
+        DeletedEntityProvider { null },
+      )
+
     private fun transaction(): Array<Any?> =
       arrayOf(
         "MainActivity",
@@ -296,6 +306,7 @@ class PersistingScopeObserverTest<T>(
         request(),
         fingerprint(),
         level(),
+        environment(),
         transaction(),
         trace(),
         contexts(),