diff --git a/.github/workflows/test-integrations-miscellaneous.yml b/.github/workflows/test-integrations-miscellaneous.yml
index 11ca9e03ae..dfc839bc7e 100644
--- a/.github/workflows/test-integrations-miscellaneous.yml
+++ b/.github/workflows/test-integrations-miscellaneous.yml
@@ -45,6 +45,10 @@ jobs:
       - name: Erase coverage
         run: |
           coverage erase
+      - name: Test launchdarkly latest
+        run: |
+          set -x # print commands that are executed
+          ./scripts/runtox.sh "py${{ matrix.python-version }}-launchdarkly-latest"
       - name: Test loguru latest
         run: |
           set -x # print commands that are executed
@@ -121,6 +125,10 @@ jobs:
       - name: Erase coverage
         run: |
           coverage erase
+      - name: Test launchdarkly pinned
+        run: |
+          set -x # print commands that are executed
+          ./scripts/runtox.sh --exclude-latest "py${{ matrix.python-version }}-launchdarkly"
       - name: Test loguru pinned
         run: |
           set -x # print commands that are executed
diff --git a/requirements-linting.txt b/requirements-linting.txt
index 4411a204db..c9d4bd7f5c 100644
--- a/requirements-linting.txt
+++ b/requirements-linting.txt
@@ -16,3 +16,4 @@ pep8-naming
 pre-commit # local linting
 httpcore
 openfeature-sdk
+launchdarkly-server-sdk
diff --git a/scripts/split-tox-gh-actions/split-tox-gh-actions.py b/scripts/split-tox-gh-actions/split-tox-gh-actions.py
index fb22f97958..c0bf2a7a09 100755
--- a/scripts/split-tox-gh-actions/split-tox-gh-actions.py
+++ b/scripts/split-tox-gh-actions/split-tox-gh-actions.py
@@ -125,6 +125,7 @@
         "tornado",
     ],
     "Miscellaneous": [
+        "launchdarkly",
         "loguru",
         "openfeature",
         "opentelemetry",
diff --git a/sentry_sdk/flag_utils.py b/sentry_sdk/flag_utils.py
index 3e18e60e07..2b345a7f0b 100644
--- a/sentry_sdk/flag_utils.py
+++ b/sentry_sdk/flag_utils.py
@@ -1,10 +1,12 @@
 from copy import copy
 from typing import TYPE_CHECKING
 
+import sentry_sdk
 from sentry_sdk._lru_cache import LRUCache
 
 if TYPE_CHECKING:
-    from typing import TypedDict
+    from typing import TypedDict, Optional
+    from sentry_sdk._types import Event, ExcInfo
 
     FlagData = TypedDict("FlagData", {"flag": str, "result": bool})
 
@@ -36,3 +38,10 @@ def get(self):
     def set(self, flag, result):
         # type: (str, bool) -> None
         self.buffer.set(flag, result)
+
+
+def flag_error_processor(event, exc_info):
+    # type: (Event, ExcInfo) -> Optional[Event]
+    scope = sentry_sdk.get_current_scope()
+    event["contexts"]["flags"] = {"values": scope.flags.get()}
+    return event
diff --git a/sentry_sdk/integrations/launchdarkly.py b/sentry_sdk/integrations/launchdarkly.py
new file mode 100644
index 0000000000..9e00e12ede
--- /dev/null
+++ b/sentry_sdk/integrations/launchdarkly.py
@@ -0,0 +1,64 @@
+from typing import TYPE_CHECKING
+import sentry_sdk
+
+from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.flag_utils import flag_error_processor
+
+try:
+    import ldclient
+    from ldclient.hook import Hook, Metadata
+
+    if TYPE_CHECKING:
+        from ldclient import LDClient
+        from ldclient.hook import EvaluationSeriesContext
+        from ldclient.evaluation import EvaluationDetail
+
+        from typing import Any
+except ImportError:
+    raise DidNotEnable("LaunchDarkly is not installed")
+
+
+class LaunchDarklyIntegration(Integration):
+    identifier = "launchdarkly"
+
+    def __init__(self, ld_client=None):
+        # type: (LDClient | None) -> None
+        """
+        :param client: An initialized LDClient instance. If a client is not provided, this
+            integration will attempt to use the shared global instance.
+        """
+        try:
+            client = ld_client or ldclient.get()
+        except Exception as exc:
+            raise DidNotEnable("Error getting LaunchDarkly client. " + repr(exc))
+
+        if not client.is_initialized():
+            raise DidNotEnable("LaunchDarkly client is not initialized.")
+
+        # Register the flag collection hook with the LD client.
+        client.add_hook(LaunchDarklyHook())
+
+    @staticmethod
+    def setup_once():
+        # type: () -> None
+        scope = sentry_sdk.get_current_scope()
+        scope.add_error_processor(flag_error_processor)
+
+
+class LaunchDarklyHook(Hook):
+
+    @property
+    def metadata(self):
+        # type: () -> Metadata
+        return Metadata(name="sentry-feature-flag-recorder")
+
+    def after_evaluation(self, series_context, data, detail):
+        # type: (EvaluationSeriesContext, dict[Any, Any], EvaluationDetail) -> dict[Any, Any]
+        if isinstance(detail.value, bool):
+            flags = sentry_sdk.get_current_scope().flags
+            flags.set(series_context.key, detail.value)
+        return data
+
+    def before_evaluation(self, series_context, data):
+        # type: (EvaluationSeriesContext, dict[Any, Any]) -> dict[Any, Any]
+        return data  # No-op.
diff --git a/sentry_sdk/integrations/openfeature.py b/sentry_sdk/integrations/openfeature.py
index 8b3b6ed9a9..18f968a703 100644
--- a/sentry_sdk/integrations/openfeature.py
+++ b/sentry_sdk/integrations/openfeature.py
@@ -2,6 +2,7 @@
 import sentry_sdk
 
 from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.flag_utils import flag_error_processor
 
 try:
     from openfeature import api
@@ -10,8 +11,6 @@
     if TYPE_CHECKING:
         from openfeature.flag_evaluation import FlagEvaluationDetails
         from openfeature.hook import HookContext, HookHints
-        from sentry_sdk._types import Event, ExcInfo
-        from typing import Optional
 except ImportError:
     raise DidNotEnable("OpenFeature is not installed")
 
@@ -22,14 +21,8 @@ class OpenFeatureIntegration(Integration):
     @staticmethod
     def setup_once():
         # type: () -> None
-        def error_processor(event, exc_info):
-            # type: (Event, ExcInfo) -> Optional[Event]
-            scope = sentry_sdk.get_current_scope()
-            event["contexts"]["flags"] = {"values": scope.flags.get()}
-            return event
-
         scope = sentry_sdk.get_current_scope()
-        scope.add_error_processor(error_processor)
+        scope.add_error_processor(flag_error_processor)
 
         # Register the hook within the global openfeature hooks list.
         api.add_hooks(hooks=[OpenFeatureHook()])
diff --git a/setup.py b/setup.py
index 7525fb3c88..e5e0c8eaa4 100644
--- a/setup.py
+++ b/setup.py
@@ -63,6 +63,7 @@ def get_file_text(file_name):
         "huey": ["huey>=2"],
         "huggingface_hub": ["huggingface_hub>=0.22"],
         "langchain": ["langchain>=0.0.210"],
+        "launchdarkly": ["launchdarkly-server-sdk>=9.8.0"],
         "litestar": ["litestar>=2.0.0"],
         "loguru": ["loguru>=0.5"],
         "openai": ["openai>=1.0.0", "tiktoken>=0.3.0"],
diff --git a/tests/integrations/launchdarkly/__init__.py b/tests/integrations/launchdarkly/__init__.py
new file mode 100644
index 0000000000..06e09884c8
--- /dev/null
+++ b/tests/integrations/launchdarkly/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+pytest.importorskip("ldclient")
diff --git a/tests/integrations/launchdarkly/test_launchdarkly.py b/tests/integrations/launchdarkly/test_launchdarkly.py
new file mode 100644
index 0000000000..acbe764104
--- /dev/null
+++ b/tests/integrations/launchdarkly/test_launchdarkly.py
@@ -0,0 +1,116 @@
+import asyncio
+import concurrent.futures as cf
+
+import ldclient
+
+import sentry_sdk
+import pytest
+
+from ldclient import LDClient
+from ldclient.config import Config
+from ldclient.context import Context
+from ldclient.integrations.test_data import TestData
+
+from sentry_sdk.integrations import DidNotEnable
+from sentry_sdk.integrations.launchdarkly import LaunchDarklyIntegration
+
+
+@pytest.mark.parametrize(
+    "use_global_client",
+    (False, True),
+)
+def test_launchdarkly_integration(sentry_init, use_global_client):
+    td = TestData.data_source()
+    config = Config("sdk-key", update_processor_class=td)
+    if use_global_client:
+        ldclient.set_config(config)
+        sentry_init(integrations=[LaunchDarklyIntegration()])
+        client = ldclient.get()
+    else:
+        client = LDClient(config=config)
+        sentry_init(integrations=[LaunchDarklyIntegration(ld_client=client)])
+
+    # Set test values
+    td.update(td.flag("hello").variation_for_all(True))
+    td.update(td.flag("world").variation_for_all(True))
+
+    # Evaluate
+    client.variation("hello", Context.create("my-org", "organization"), False)
+    client.variation("world", Context.create("user1", "user"), False)
+    client.variation("other", Context.create("user2", "user"), False)
+
+    assert sentry_sdk.get_current_scope().flags.get() == [
+        {"flag": "hello", "result": True},
+        {"flag": "world", "result": True},
+        {"flag": "other", "result": False},
+    ]
+
+
+def test_launchdarkly_integration_threaded(sentry_init):
+    td = TestData.data_source()
+    client = LDClient(config=Config("sdk-key", update_processor_class=td))
+    sentry_init(integrations=[LaunchDarklyIntegration(ld_client=client)])
+    context = Context.create("user1")
+
+    def task(flag_key):
+        # Creates a new isolation scope for the thread.
+        # This means the evaluations in each task are captured separately.
+        with sentry_sdk.isolation_scope():
+            client.variation(flag_key, context, False)
+            return [f["flag"] for f in sentry_sdk.get_current_scope().flags.get()]
+
+    td.update(td.flag("hello").variation_for_all(True))
+    td.update(td.flag("world").variation_for_all(False))
+    # Capture an eval before we split isolation scopes.
+    client.variation("hello", context, False)
+
+    with cf.ThreadPoolExecutor(max_workers=2) as pool:
+        results = list(pool.map(task, ["world", "other"]))
+
+    assert results[0] == ["hello", "world"]
+    assert results[1] == ["hello", "other"]
+
+
+def test_launchdarkly_integration_asyncio(sentry_init):
+    """Assert concurrently evaluated flags do not pollute one another."""
+    td = TestData.data_source()
+    client = LDClient(config=Config("sdk-key", update_processor_class=td))
+    sentry_init(integrations=[LaunchDarklyIntegration(ld_client=client)])
+    context = Context.create("user1")
+
+    async def task(flag_key):
+        with sentry_sdk.isolation_scope():
+            client.variation(flag_key, context, False)
+            return [f["flag"] for f in sentry_sdk.get_current_scope().flags.get()]
+
+    async def runner():
+        return asyncio.gather(task("world"), task("other"))
+
+    td.update(td.flag("hello").variation_for_all(True))
+    td.update(td.flag("world").variation_for_all(False))
+    client.variation("hello", context, False)
+
+    results = asyncio.run(runner()).result()
+    assert results[0] == ["hello", "world"]
+    assert results[1] == ["hello", "other"]
+
+
+def test_launchdarkly_integration_did_not_enable(monkeypatch):
+    # Client is not passed in and set_config wasn't called.
+    # TODO: Bad practice to access internals like this. We can skip this test, or remove this
+    #  case entirely (force user to pass in a client instance).
+    ldclient._reset_client()
+    try:
+        ldclient.__lock.lock()
+        ldclient.__config = None
+    finally:
+        ldclient.__lock.unlock()
+
+    with pytest.raises(DidNotEnable):
+        LaunchDarklyIntegration()
+
+    # Client not initialized.
+    client = LDClient(config=Config("sdk-key"))
+    monkeypatch.setattr(client, "is_initialized", lambda: False)
+    with pytest.raises(DidNotEnable):
+        LaunchDarklyIntegration(ld_client=client)
diff --git a/tox.ini b/tox.ini
index 7418cc0593..cd4dca2481 100644
--- a/tox.ini
+++ b/tox.ini
@@ -188,6 +188,10 @@ envlist =
     {py3.8,py3.12,py3.13}-openfeature-v0.7
     {py3.8,py3.12,py3.13}-openfeature-latest
 
+    # LaunchDarkly
+    {py3.8,py3.12,py3.13}-launchdarkly-v9.8.0
+    {py3.8,py3.12,py3.13}-launchdarkly-latest
+
     # OpenTelemetry (OTel)
     {py3.7,py3.9,py3.12,py3.13}-opentelemetry
 
@@ -547,6 +551,10 @@ deps =
     openfeature-v0.7: openfeature-sdk~=0.7.1
     openfeature-latest: openfeature-sdk
 
+    # LaunchDarkly
+    launchdarkly-v9.8.0: launchdarkly-server-sdk~=9.8.0
+    launchdarkly-latest: launchdarkly-server-sdk
+
     # OpenTelemetry (OTel)
     opentelemetry: opentelemetry-distro
 
@@ -730,6 +738,7 @@ setenv =
     huey: TESTPATH=tests/integrations/huey
     huggingface_hub: TESTPATH=tests/integrations/huggingface_hub
     langchain: TESTPATH=tests/integrations/langchain
+    launchdarkly: TESTPATH=tests/integrations/launchdarkly
     litestar: TESTPATH=tests/integrations/litestar
     loguru: TESTPATH=tests/integrations/loguru
     openai: TESTPATH=tests/integrations/openai