diff --git a/src/platform-includes/capture-error/kotlin-multiplatform.mdx b/src/platform-includes/capture-error/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..cfff99bfea086d
--- /dev/null
+++ b/src/platform-includes/capture-error/kotlin-multiplatform.mdx
@@ -0,0 +1,5 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+Sentry.captureException(exception)
+```
diff --git a/src/platform-includes/capture-message/kotlin-multiplatform.mdx b/src/platform-includes/capture-message/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..0c0dcbf49f38d3
--- /dev/null
+++ b/src/platform-includes/capture-message/kotlin-multiplatform.mdx
@@ -0,0 +1,5 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+Sentry.captureMessage("Something went wrong")
+```
diff --git a/src/platform-includes/configuration/config-intro/kotlin-multiplatform.mdx b/src/platform-includes/configuration/config-intro/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..0c44fb46eeb923
--- /dev/null
+++ b/src/platform-includes/configuration/config-intro/kotlin-multiplatform.mdx
@@ -0,0 +1,9 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+// Application context is only needed for Android targets
+Sentry.init(context) { options ->
+  options.dsn = "___PUBLIC_DSN___"
+  options.release = "io.sentry.samples@3.0.0+1"
+}
+```
diff --git a/src/platform-includes/configuration/drain-example/kotlin-multiplatform.mdx b/src/platform-includes/configuration/drain-example/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..222be9810cee66
--- /dev/null
+++ b/src/platform-includes/configuration/drain-example/kotlin-multiplatform.mdx
@@ -0,0 +1 @@
+The Kotlin Multiplatform SDK uses native SDKs to automatically store Sentry events on the device's disk before shutdown.
diff --git a/src/platform-includes/enriching-events/add-attachment/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/add-attachment/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..67422586c4eec6
--- /dev/null
+++ b/src/platform-includes/enriching-events/add-attachment/kotlin-multiplatform.mdx
@@ -0,0 +1,16 @@
+To add an attachment, either add it to the scope or pass it to any of the `capture` methods.
+
+### Passing Attachments to Capture
+
+You can pass attachments to any of the `capture` methods. For example, when capturing an exception:
+
+```kotlin
+import io.sentry.kotlin.multiplatform.Attachment
+import io.sentry.kotlin.multiplatform.Sentry
+
+val fileAttachment = Attachment("your/path/file.log")
+
+Sentry.captureException(IllegalStateException()) { scope ->
+  scope.addAttachment(fileAttachment)
+}
+```
diff --git a/src/platform-includes/enriching-events/attach-screenshots/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/attach-screenshots/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..0a981315c999ef
--- /dev/null
+++ b/src/platform-includes/enriching-events/attach-screenshots/kotlin-multiplatform.mdx
@@ -0,0 +1,8 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+// Application context is only needed for Android targets
+Sentry.init(context) { options ->
+  options.attachScreenshot = true
+}
+```
diff --git a/src/platform-includes/enriching-events/attach-viewhierarchy/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/attach-viewhierarchy/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..6126fd6ad8d6b6
--- /dev/null
+++ b/src/platform-includes/enriching-events/attach-viewhierarchy/kotlin-multiplatform.mdx
@@ -0,0 +1,15 @@
+<Note>
+
+Currently only available on iOS and Android.
+
+</Note>
+
+```kotlin
+import io.sentry.kotlin.multiplatform.sentry
+
+// Application context is only needed for Android targets
+Sentry.init(context) { options ->
+  options.dsn = "___PUBLIC_DSN___"
+  options.attachViewHierarchy = true
+}
+```
diff --git a/src/platform-includes/enriching-events/attachment-init-with-bytes/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/attachment-init-with-bytes/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..2bbbfc4c44972f
--- /dev/null
+++ b/src/platform-includes/enriching-events/attachment-init-with-bytes/kotlin-multiplatform.mdx
@@ -0,0 +1,6 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+import io.sentry.kotlin.multiplatform.Attachment
+
+val attachment = Attachment(bytes, "file.log")
+```
diff --git a/src/platform-includes/enriching-events/attachment-init-with-path/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/attachment-init-with-path/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..08f8c232176dcd
--- /dev/null
+++ b/src/platform-includes/enriching-events/attachment-init-with-path/kotlin-multiplatform.mdx
@@ -0,0 +1,6 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+import io.sentry.kotlin.multiplatform.Attachment
+
+val attachment = Attachment("your/path/file.log")
+```
diff --git a/src/platform-includes/enriching-events/attachment-max-size/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/attachment-max-size/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..47fb384d49cd89
--- /dev/null
+++ b/src/platform-includes/enriching-events/attachment-max-size/kotlin-multiplatform.mdx
@@ -0,0 +1,8 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+// Application context is only needed for Android targets
+Sentry.init(context) { options ->
+  options.maxAttachmentSize = 5 * 1024 * 1024 // 5 MiB
+}
+```
diff --git a/src/platform-includes/enriching-events/attachment-upload/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/attachment-upload/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..6e70607f385089
--- /dev/null
+++ b/src/platform-includes/enriching-events/attachment-upload/kotlin-multiplatform.mdx
@@ -0,0 +1,16 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+import io.sentry.kotlin.multiplatform.Attachment
+
+val fileAttachment = Attachment("your/path/file.log")
+
+// Global Scope
+Sentry.configureScope { scope ->
+  scope.addAttachment(fileAttachment)
+}
+
+// Clear all attachments in the global Scope
+Sentry.configureScope { scope ->
+  scope.clearAttachments()
+}
+```
diff --git a/src/platform-includes/enriching-events/breadcrumbs/before-breadcrumb/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/breadcrumbs/before-breadcrumb/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..52f060b42d0aeb
--- /dev/null
+++ b/src/platform-includes/enriching-events/breadcrumbs/before-breadcrumb/kotlin-multiplatform.mdx
@@ -0,0 +1,14 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+// Application context is only needed for Android targets
+Sentry.init(context) { options ->
+  options.beforeBreadcrumb = { breadcrumb ->
+    if ("a.spammy.Logger" == breadcrumb.category) {
+      null
+    } else {
+      breadcrumb
+    }
+  }
+}
+```
diff --git a/src/platform-includes/enriching-events/breadcrumbs/breadcrumbs-example/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/breadcrumbs/breadcrumbs-example/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..49a0f64f433a27
--- /dev/null
+++ b/src/platform-includes/enriching-events/breadcrumbs/breadcrumbs-example/kotlin-multiplatform.mdx
@@ -0,0 +1,12 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+import io.sentry.kotlin.multiplatform.SentryLevel
+import io.sentry.kotlin.multiplatform.protocol.Breadcrumb
+
+val breadcrumb = Breadcrumb().apply {
+    category = "auth"
+    message = "Authenticated user ${user.email}"
+    level = SentryLevel.INFO
+}
+Sentry.addBreadcrumb(breadcrumb)
+```
diff --git a/src/platform-includes/enriching-events/scopes/configure-scope/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/scopes/configure-scope/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..70b661d03c81ae
--- /dev/null
+++ b/src/platform-includes/enriching-events/scopes/configure-scope/kotlin-multiplatform.mdx
@@ -0,0 +1,12 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+import io.sentry.kotlin.multiplatform.protocol.User
+
+Sentry.configureScope { scope ->
+  scope.setTag("my-tag", "my value")
+  scope.user = User().apply {
+    id = "42"
+    email = "john.doe@example.com"
+  }
+}
+```
diff --git a/src/platform-includes/enriching-events/scopes/scope-callback-param/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/scopes/scope-callback-param/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..02a92f609745c8
--- /dev/null
+++ b/src/platform-includes/enriching-events/scopes/scope-callback-param/kotlin-multiplatform.mdx
@@ -0,0 +1,13 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+import io.sentry.kotlin.multiplatform.SentryLevel
+
+// will be tagged with my-tag="my value"
+Sentry.captureException(Exception("my error")) { scope ->
+  scope.setTag("my-tag", "my value")
+  scope.level = SentryLevel.WARNING
+}
+
+// will not be tagged with my-tag
+Sentry.captureException(Exception("my error"))
+```
diff --git a/src/platform-includes/enriching-events/set-context/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/set-context/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..7afba436617c36
--- /dev/null
+++ b/src/platform-includes/enriching-events/set-context/kotlin-multiplatform.mdx
@@ -0,0 +1,9 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+Sentry.configureScope { scope ->
+  scope.setContext("name", "Mighty Fighter")
+  scope.setContext("age", 19)
+  scope.setContext("attack_type", "melee")
+}
+```
diff --git a/src/platform-includes/enriching-events/set-tag/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/set-tag/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..49185a2057dc54
--- /dev/null
+++ b/src/platform-includes/enriching-events/set-tag/kotlin-multiplatform.mdx
@@ -0,0 +1,7 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+Sentry.configureScope { scope ->
+  scope.setTag("page.locale", "de-at")
+}
+```
diff --git a/src/platform-includes/enriching-events/set-user/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/set-user/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..2ec9681c0edf16
--- /dev/null
+++ b/src/platform-includes/enriching-events/set-user/kotlin-multiplatform.mdx
@@ -0,0 +1,9 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+import io.sentry.kotlin.multiplatform.protocol.User
+
+val user = User().apply {
+  email = "jane.doe@example.com"
+}
+Sentry.setUser(user)
+```
diff --git a/src/platform-includes/enriching-events/unset-user/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/unset-user/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..7f68baea82f371
--- /dev/null
+++ b/src/platform-includes/enriching-events/unset-user/kotlin-multiplatform.mdx
@@ -0,0 +1,7 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+Sentry.configureScope { scope ->
+  scope.user = null
+}
+```
diff --git a/src/platform-includes/enriching-events/user-feedback/sdk-api-example/kotlin-multiplatform.mdx b/src/platform-includes/enriching-events/user-feedback/sdk-api-example/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..76a20af3473a78
--- /dev/null
+++ b/src/platform-includes/enriching-events/user-feedback/sdk-api-example/kotlin-multiplatform.mdx
@@ -0,0 +1,13 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+import io.sentry.kotlin.multiplatform.protocol.UserFeedback
+
+val sentryId = Sentry.captureMessage("My message")
+
+val userFeedback = UserFeedback(sentryId).apply {
+  comments = "It broke."
+  email = "john.doe@example.com"
+  name = "John Doe"
+}
+Sentry.captureUserFeedback(userFeedback)
+```
diff --git a/src/platform-includes/getting-started-config/kotlin-multiplatform.mdx b/src/platform-includes/getting-started-config/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..5c4eef92571141
--- /dev/null
+++ b/src/platform-includes/getting-started-config/kotlin-multiplatform.mdx
@@ -0,0 +1,8 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+// Application context is only needed for Android targets
+Sentry.init(context) { ->
+  options.dsn = "___PUBLIC_DSN___"
+}
+```
diff --git a/src/platform-includes/getting-started-install/kotlin-multiplatform.mdx b/src/platform-includes/getting-started-install/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..61aa885f4bdfaf
--- /dev/null
+++ b/src/platform-includes/getting-started-install/kotlin-multiplatform.mdx
@@ -0,0 +1,48 @@
+### Prerequisites (Android)
+
+Android requires disabling auto-init to not clash with the ContentProvider, which auto-initializes the Sentry Android SDK. To do so, add the following to the AndroidManifest.xml file under your androidMain source set:
+
+```xml
+<application>
+    <meta-data android:name="io.sentry.auto-init" android:value="false" />
+</application>
+```
+
+To install the Kotlin Multiplatform SDK, you need to add the following to your `build.gradle.kts` file in your shared module:
+
+```kotlin {filename:shared/build.gradle.kts}
+repositories {
+    mavenCentral()
+}
+
+kotlin {
+  val commonMain by getting {
+    dependencies {
+      api("io.sentry:sentry-kotlin-multiplatform:{{ packages.version('sentry.kotlin.kmp', '0.0.1-alpha.2') }}")
+    }
+  }
+
+  // Android target
+  val androidMain by getting {
+    dependsOn(commonMain)
+  }
+
+  // Apple targets:
+  val iosMain by getting {
+    dependsOn(commonMain)
+  }
+
+  cocoapods {
+    summary = "Some description for the Shared Module"
+    homepage = "Link to the Shared Module homepage"
+    ios.deploymentTarget = "14.1"
+    podfile = project.file("../iosApp/Podfile")
+    pod("Sentry", "~> {{ packages.version('sentry.cocoa', '8.2.0') }}")
+
+    framework {
+      baseName = "shared"
+      export("io.sentry:sentry-kotlin-multiplatform:{{ packages.version('sentry.kotlin.kmp', '0.0.1-alpha.2') }}")
+    }
+  }
+}
+```
diff --git a/src/platform-includes/getting-started-primer/kotlin-multiplatform.mdx b/src/platform-includes/getting-started-primer/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..aec9868cdeeffa
--- /dev/null
+++ b/src/platform-includes/getting-started-primer/kotlin-multiplatform.mdx
@@ -0,0 +1,13 @@
+Sentry's Kotlin Multiplatform SDK builds on top of multiple Sentry SDKs, allowing developers to use the same codebase and share code between platforms while being able to integrate Sentry's features into their applications.
+
+## Overview of Features
+
+- Native crash reporting for Android and JVM, leveraging our [Android SDK](/platforms/android) and [Java SDK](/platforms/java)
+- Native crash reporting for iOS, macOS, tvOS, and watchOS, leveraging our [Cocoa SDK](/platforms/apple)
+- Automatic breadcrumbs for app lifecycle and UI events
+
+<Note>
+
+This SDK is currently experimental.
+
+</Note>
diff --git a/src/platform-includes/getting-started-verify/kotlin-multiplatform.mdx b/src/platform-includes/getting-started-verify/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..42dc9b122bae6a
--- /dev/null
+++ b/src/platform-includes/getting-started-verify/kotlin-multiplatform.mdx
@@ -0,0 +1,11 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+fun captureError() {
+    try {
+      throw Exception("This is a test.")
+    } catch (e: Exception) {
+      Sentry.captureException(e)
+    }
+}
+```
diff --git a/src/platform-includes/set-environment/kotlin-multiplatform.mdx b/src/platform-includes/set-environment/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..0298e873b4ea32
--- /dev/null
+++ b/src/platform-includes/set-environment/kotlin-multiplatform.mdx
@@ -0,0 +1,8 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+// Application context is only needed for Android targets
+Sentry.init(context) {
+  it.environment = "production"
+}
+```
diff --git a/src/platform-includes/set-level/kotlin-multiplatform.mdx b/src/platform-includes/set-level/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..62e75281df790f
--- /dev/null
+++ b/src/platform-includes/set-level/kotlin-multiplatform.mdx
@@ -0,0 +1,8 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+import io.sentry.kotlin.multiplatform.SentryLevel
+
+Sentry.configureScope { scope ->
+  scope.level = SentryLevel.WARNING
+}
+```
diff --git a/src/platform-includes/set-release/kotlin-multiplatform.mdx b/src/platform-includes/set-release/kotlin-multiplatform.mdx
new file mode 100644
index 00000000000000..83b38c4a8038e5
--- /dev/null
+++ b/src/platform-includes/set-release/kotlin-multiplatform.mdx
@@ -0,0 +1,10 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+// Application context is only needed for Android targets
+Sentry.init(context) { options ->
+  options.release = "io.example@1.1.0"
+}
+```
+
+If no release name is set, the SDK creates a default, depending on the native platform.
diff --git a/src/platforms/common/configuration/filtering.mdx b/src/platforms/common/configuration/filtering.mdx
index 43ebaeb39d87df..ac4af6fca421cd 100644
--- a/src/platforms/common/configuration/filtering.mdx
+++ b/src/platforms/common/configuration/filtering.mdx
@@ -4,9 +4,10 @@ sidebar_order: 60
 description: "Learn more about how to configure your SDK to filter events reported to Sentry."
 notSupported:
   - perl
+  - kotlin-multiplatform
 ---
 
-Adding Sentry to your app gives you a great deal of very valuable information about errors and performance you wouldn't otherwise get. And lots of information is good -- as long as it's the right information, at a reasonable volume.
+When you add Sentry to your app, you get a lot of valuable information about errors and performance. And lots of information is good -- as long as it's the right information, at a reasonable volume.
 
 The Sentry SDKs have several configuration options to help you filter out events.
 
diff --git a/src/platforms/common/data-management/sensitive-data/index.mdx b/src/platforms/common/data-management/sensitive-data/index.mdx
index 56ea3bbd47c748..df4c891fe39fef 100644
--- a/src/platforms/common/data-management/sensitive-data/index.mdx
+++ b/src/platforms/common/data-management/sensitive-data/index.mdx
@@ -29,7 +29,7 @@ If you are using Sentry in your mobile app, read our [frequently asked questions
 
 </Note>
 
-<PlatformSection notSupported={["apple", "javascript", "node", "perl", "native.breakpad", "native.crashpad", "native.minidumps", "native.wasm", "unreal", "go", "ruby", "native", "elixir", "dart", "flutter", "unity"]}>
+<PlatformSection notSupported={["apple", "javascript", "node", "perl", "native.breakpad", "native.crashpad", "native.minidumps", "native.wasm", "unreal", "go", "ruby", "native", "elixir", "dart", "flutter", "unity", "kotlin-multiplatform"]}>
 
 ## Personally Identifiable Information (PII)
 
@@ -45,7 +45,7 @@ If you _do not_ wish to use the default PII behavior, you can also choose to ide
 
 </PlatformSection>
 
-<PlatformSection notSupported={["perl", "unreal", "native.breakpad", "native.crashpad", "native.minidumps", "native.wasm", "unity"]}>
+<PlatformSection notSupported={["perl", "unreal", "native.breakpad", "native.crashpad", "native.minidumps", "native.wasm", "unity", "kotlin-multiplatform"]}>
 
 ## Scrubbing Data
 
diff --git a/src/platforms/common/enriching-events/attachments/index.mdx b/src/platforms/common/enriching-events/attachments/index.mdx
index a96501e984bedc..68ca4a35448e1a 100644
--- a/src/platforms/common/enriching-events/attachments/index.mdx
+++ b/src/platforms/common/enriching-events/attachments/index.mdx
@@ -15,7 +15,7 @@ supported:
   - unreal
   - react-native
   - python
-
+  - kotlin-multiplatform
 ---
 
 <PlatformSection supported={["apple", "android", "java"]}>
@@ -58,7 +58,7 @@ To receive symbolicated stack traces, you have to upload debug information to Se
 
 </PlatformSection>
 
-<PlatformSection supported={["android", "apple", "java", "dotnet", "dart", "flutter", "unreal"]}>
+<PlatformSection supported={["android", "apple", "java", "dotnet", "dart", "flutter", "unreal", "kotlin-multiplatform"]}>
 
 ## Creating Attachments
 
@@ -86,7 +86,7 @@ In addition, you can set these parameters:
 
 ## Uploading Attachments
 
-<PlatformSection supported={["native", "javascript", "java", "python"]}>
+<PlatformSection supported={["native", "javascript", "java", "python", "kotlin-multiplatform"]}>
 
 <PlatformSection supported={["javascript", "node"]}>
 
@@ -100,7 +100,7 @@ You'll first need to import the SDK, as usual:
 
 </PlatformSection>
 
-<PlatformSection notSupported={["unity", "android"]} supported={["apple", "java", "dotnet", "dart", "flutter", "unreal"]}>
+<PlatformSection notSupported={["unity", "android"]} supported={["apple", "java", "dotnet", "dart", "flutter", "unreal", "kotlin-multiplatform"]}>
 
 Attachments live on the <PlatformLink to="/enriching-events/scopes/">Scope</PlatformLink>. You can either add an attachment on the global scope to be sent with every event or add it on the <PlatformLink to="/enriching-events/scopes/#local-scopes">local Scope</PlatformLink> to just send the attachment with one specific event.
 
diff --git a/src/platforms/common/enriching-events/breadcrumbs.mdx b/src/platforms/common/enriching-events/breadcrumbs.mdx
index 9eb54e545df48f..cd41cc2fc57bbd 100644
--- a/src/platforms/common/enriching-events/breadcrumbs.mdx
+++ b/src/platforms/common/enriching-events/breadcrumbs.mdx
@@ -71,7 +71,7 @@ This hook is passed an already assembled breadcrumb and, in some SDKs, an option
 
 <PlatformContent includePath="enriching-events/breadcrumbs/before-breadcrumb" />
 
-<PlatformSection notSupported={["apple", "dotnet", "unity"]}>
+<PlatformSection notSupported={["apple", "dotnet", "unity", "kotlin-multiplatform"]}>
 
 For information about what can be done with the hint, see <PlatformLink to="/configuration/filtering/#using-hints">Filtering Events</PlatformLink>.
 
diff --git a/src/platforms/common/enriching-events/event-processors.mdx b/src/platforms/common/enriching-events/event-processors.mdx
index 3e8fc51c153891..78514a3d76d9a0 100644
--- a/src/platforms/common/enriching-events/event-processors.mdx
+++ b/src/platforms/common/enriching-events/event-processors.mdx
@@ -19,6 +19,7 @@ notSupported:
   - rust
   - unity
   - unreal
+  - kotlin-multiplatform
 ---
 
 You can enrich events with additional data by adding your own event processors, either on the scope level or globally. Though event processors are similar to <PlatformIdentifier name="before-send" /> and <PlatformIdentifier name="before-send-transaction" />, there are two key differences:
diff --git a/src/platforms/common/enriching-events/scopes.mdx b/src/platforms/common/enriching-events/scopes.mdx
index cb3d97c6de800d..8bf38635040e5d 100644
--- a/src/platforms/common/enriching-events/scopes.mdx
+++ b/src/platforms/common/enriching-events/scopes.mdx
@@ -69,7 +69,7 @@ The Native SDK currently only provides a single scope shared by all threads in t
 
 For details on how this affects performance monitoring, check out the [Connect Errors With Spans](/platforms/native/performance/instrumentation/custom-instrumentation/#connect-errors-with-spans) section of "Custom Instrumentation".
 
-</Alert> 
+</Alert>
 </PlatformSection>
 
 ## Configuring the Scope
@@ -111,7 +111,7 @@ We also support pushing and configuring a scope within a single call. This is ty
 called `with-scope`, `push-scope` or implemented as a function parameter on the capture methods, depending on the SDK. It's very helpful if
 you only want to send data for one specific event.
 
-<PlatformSection supported={["go", "java", "javascript", "php", "python", "ruby", "rust"]} notSupported={["android"]}>
+<PlatformSection supported={["go", "java", "javascript", "php", "python", "ruby", "rust"]} notSupported={["android", "kotlin-multiplatform"]}>
 
 ### Using `with-scope`
 
@@ -141,7 +141,7 @@ caught, and all errors that occur will be silently ignored and **not** reported.
 
 </PlatformSection>
 
-<PlatformSection supported={["apple", "dart", "dotnet", "java", "unreal"]}>
+<PlatformSection supported={["apple", "dart", "dotnet", "java", "unreal", "kotlin-multiplatform"]}>
 
 ### Using Scope Callback Parameter
 
@@ -165,7 +165,7 @@ caught, and all errors that occur will be silently ignored and **not** reported.
 
 </PlatformSection>
 
-<PlatformSection supported={["java"]} notSupported={["android"]}>
+<PlatformSection supported={["java"]} notSupported={["android", "kotlin-multiplatform"]}>
 
 ## Kotlin Coroutines
 
diff --git a/src/platforms/common/enriching-events/screenshots.mdx b/src/platforms/common/enriching-events/screenshots.mdx
index 143ce1f95be449..c3c664f266147d 100644
--- a/src/platforms/common/enriching-events/screenshots.mdx
+++ b/src/platforms/common/enriching-events/screenshots.mdx
@@ -10,6 +10,7 @@ supported:
   - javascript.electron
   - flutter
   - react-native
+  - kotlin-multiplatform
 notSupported:
   - apple.macos
   - apple.tvos
@@ -24,6 +25,16 @@ This feature only applies to SDKs with a user interface, such as the ones for mo
 
 Screenshots may contain <PlatformLink to="/data-management/sensitive-data/">PII</PlatformLink> and is an opt-in feature. You can enable it as shown below:
 
+<PlatformSection supported={["kotlin-multiplatform"]}>
+
+<Note>
+
+This feature is supported for iOS and Android only.
+
+</Note>
+
+</PlatformSection>
+
 <PlatformContent includePath="enriching-events/attach-screenshots" />
 
 <PlatformSection supported={["react-native"]}>
diff --git a/src/platforms/common/enriching-events/user-feedback.mdx b/src/platforms/common/enriching-events/user-feedback.mdx
index 9ae9bb9a8b6e48..e0591c8f056373 100644
--- a/src/platforms/common/enriching-events/user-feedback.mdx
+++ b/src/platforms/common/enriching-events/user-feedback.mdx
@@ -20,13 +20,13 @@ While this feature isn't currently supported for Ruby or most of its frameworks,
 
 </PlatformSection>
 
-<PlatformSection supported={["java", "apple", "android", "dart", "flutter", "unreal", "react-native"]} >
+<PlatformSection supported={["java", "apple", "android", "dart", "flutter", "unreal", "react-native", "kotlin-multiplatform"]} >
 
 ## User Feedback API
 
 The user feedback API provides the ability to collect user information when an event occurs. You can use the same programming language you have in your app to send user feedback. In this case, the SDK creates the HTTP request so you don't have to deal with posting data via HTTP.
 
-<PlatformSection notSupported={["unreal"]}>
+<PlatformSection notSupported={["unreal", "kotlin-multiplatform"]}>
 
 Sentry pairs the feedback with the original event, giving you additional insight into issues. Sentry needs the `eventId` to be able to associate the user feedback to the corresponding event. For example, to get the `eventId`, you can use <PlatformLink to="/configuration/options/#before-send"><PlatformIdentifier name="before-send" /></PlatformLink> or the return value of the method capturing an event.
 
@@ -66,7 +66,7 @@ SentrySdk.CaptureUserFeedback(eventId, "user@example.com", "It broke.", "The Use
 
 </PlatformSection>
 
-<PlatformSection notSupported={["android", "apple", "java", "native", "dart", "flutter", "ruby", "unity", "react-native", "unreal"]}>
+<PlatformSection notSupported={["android", "apple", "java", "native", "dart", "flutter", "ruby", "unity", "react-native", "unreal", "kotlin-multiplatform"]}>
 
 ## Embeddable JavaScript Widget
 
diff --git a/src/platforms/common/enriching-events/viewhierarchy.mdx b/src/platforms/common/enriching-events/viewhierarchy.mdx
index 7e5ea268c976a5..42b9e20a0693e1 100644
--- a/src/platforms/common/enriching-events/viewhierarchy.mdx
+++ b/src/platforms/common/enriching-events/viewhierarchy.mdx
@@ -7,6 +7,7 @@ supported:
   - flutter
   - android
   - react-native
+  - kotlin-multiplatform
 notSupported:
   - apple.macos
   - apple.tvos
diff --git a/src/platforms/common/index.mdx b/src/platforms/common/index.mdx
index 21b8cc6e5c22b6..d620aea0825a01 100644
--- a/src/platforms/common/index.mdx
+++ b/src/platforms/common/index.mdx
@@ -2,7 +2,7 @@
 
 On this page, we get you up and running with Sentry's SDK, so that it will automatically report errors and exceptions in your application.
 
-<PlatformSection noGuides notSupported={["android", "dart", "elixir", "flutter", "perl", "react-native", "unity", "unreal"]}>
+<PlatformSection noGuides notSupported={["android", "dart", "elixir", "flutter", "perl", "react-native", "unity", "unreal", "kotlin-multiplatform"]}>
 
 <Alert level="info" title="Using a framework?">
 
diff --git a/src/platforms/common/usage/sdk-fingerprinting.mdx b/src/platforms/common/usage/sdk-fingerprinting.mdx
index 135645c45055d5..99927e34e8e0a3 100644
--- a/src/platforms/common/usage/sdk-fingerprinting.mdx
+++ b/src/platforms/common/usage/sdk-fingerprinting.mdx
@@ -11,6 +11,7 @@ notSupported:
   - unreal
   - rust
   - elixir
+  - kotlin-multiplatform
 ---
 
 All events have a fingerprint. Events with the same fingerprint are grouped together into an issue.
diff --git a/src/platforms/kotlin-multiplatform/config.yml b/src/platforms/kotlin-multiplatform/config.yml
new file mode 100644
index 00000000000000..d42c93c517a201
--- /dev/null
+++ b/src/platforms/kotlin-multiplatform/config.yml
@@ -0,0 +1,9 @@
+title: Kotlin Multiplatform
+caseStyle: camelCase
+fallbackPlatform: java
+supportLevel: production
+sdk: sentry.kotlin.kmp
+categories:
+  - mobile
+  - desktop
+keywords: ["kotlin"]
diff --git a/src/platforms/kotlin-multiplatform/initialization-strategies.mdx b/src/platforms/kotlin-multiplatform/initialization-strategies.mdx
new file mode 100644
index 00000000000000..39a046a37ca137
--- /dev/null
+++ b/src/platforms/kotlin-multiplatform/initialization-strategies.mdx
@@ -0,0 +1,102 @@
+---
+title: Initialization Strategies
+sidebar_order: 0
+description: "Strategies for initializing the Kotlin Multiplatform SDK."
+---
+
+When it comes to initializing a Kotlin Multiplatform SDK, there are three strategies to consider:
+ - [Shared initializer](#shared-initializer)
+ - [Platform specific initializers](#platform-specific-initializers)
+ - [Hybrid approach](#hybrid-approach)
+
+## Shared Initializer
+
+The shared initializer approach involves initializing the SDK in your shared codebase, using the same configuration options for all platforms. This approach is ideal for projects that prioritize consistency across platforms and do not require platform-specific customizations.
+
+Using a shared initializer provides a single source of truth for your SDK's configuration options. This can simplify maintenance and debugging efforts, as you only need to update one codebase for all platforms.
+
+To initialize the SDK, create a Kotlin file in your `commonMain` e.g. `AppSetup.kt`, (or whatever you decide to call it), and create an initialization function. You'll then be able to call it in an early lifecycle stage in your platforms.
+
+```kotlin {filename:AppSetup.kt}
+import io.sentry.kotlin.multiplatform.Context
+import io.sentry.kotlin.multiplatform.Sentry
+
+// Application context is only needed for Android targets
+fun initializeSentry(context: Context?) {
+  Sentry.init(context) {
+    it.dsn = "___PUBLIC_DSN___"
+  }
+}
+```
+
+### Android
+
+```kotlin {filename:MainActivity.kt}
+import your.kmp.app.initializeSentry
+
+class YourApplication : Application() {
+  override fun onCreate() {
+    super.onCreate()
+      // Make sure to add the context!
+      initializeSentry(this)
+   }
+}
+```
+
+### Cocoa/Apple
+
+```swift {filename:AppDelegate.swift}
+import shared
+
+func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil
+) -> Bool {
+    AppSetupKt.initializeSentry(context = nil)
+    return true
+}
+```
+
+## Platform-Specific Initializers
+
+Platform-specific initializers allow for customization of the SDK's configuration options on a per-platform basis. This approach can be particularly useful when your SDK requires platform-specific functionality or performance optimizations.
+
+With platform-specific initializers, you can initialize the SDK directly in the target platform's codebase. This approach gives you the flexibility to fine-tune the SDK's behavior to meet the unique needs of each platform.
+
+### Android
+
+```kotlin {filename:MainActivity.kt}
+import io.sentry.kotlin.multiplatform.Sentry
+
+class YourApplication : Application() {
+  override fun onCreate() {
+    super.onCreate()
+      // Make sure to add the context!
+      Sentry.init(this) {
+        it.dsn = "___PUBLIC_DSN___"
+      }
+   }
+}
+```
+
+### Cocoa/Apple
+
+```swift {filename:AppDelegate.swift}
+import shared
+
+func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil
+) -> Bool {
+    Sentry.shared.doInit() { options in
+      options.dsn = "___PUBLIC_DSN___"
+    }
+    return true
+}
+```
+
+## Hybrid Approach
+
+It's also possible to mix the two initialization strategies by creating custom `sourceSets` that only target specific platforms. This allows you to use a shared initializer for some platforms while utilizing platform-specific initializers for others.
+
+For example, you may choose to use a shared initializer for Android and iOS platforms, while using a platform-specific initializer for the watchOS and tvOS platform. This approach provides a balance between consistency and customization.
diff --git a/src/platforms/kotlin/index.mdx b/src/platforms/kotlin/index.mdx
index 286419b861efd3..bfd8afe4527a19 100644
--- a/src/platforms/kotlin/index.mdx
+++ b/src/platforms/kotlin/index.mdx
@@ -4,9 +4,8 @@ Select your platform to get started:
 
 - [Java](/platforms/java)
 - [Android](/platforms/android)
+- [Kotlin Multiplatform](/platforms/kotlin-multiplatform)
 
 ## Kotlin Extensions
 
 - [Using Sentry SDK with Coroutines](/platforms/java/enriching-events/scopes/#kotlin-coroutines)
-
-We are also working on an [experimental SDK for Kotlin Multiplatform](https://github.com/getsentry/sentry-kotlin-multiplatform). Feedback welcome.