diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5d46ae3d3cc..967c1a6b9be 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -68,6 +68,10 @@ multiple files:
 
 ### Editors
 
+#### Other changes
+
+- The Rome LSP is now able to show diagnostics that belong to JSON lint rules.
+
 ### Formatter
 
 - Added a new option called `--jsx-quote-style` to the formatter. This option allows you to choose between single and double quotes for JSX attributes. [#4486](https://github.com/rome/tools/issues/4486)
@@ -96,6 +100,8 @@ multiple files:
   This rule proposes turning function expressions into arrow functions.
   Function expressions that use `this` are ignored.
 
+- [`noDuplicateJsonKeys`](https://docs.rome.tools/lint/rules/noDuplicateJsonKeys/)
+
 #### Other changes
 
 - [`noRedeclare`](https://docs.rome.tools/lint/rules/noredeclare/): allow redeclare of index signatures are in different type members [#4478](https://github.com/rome/tools/issues/4478)
diff --git a/Cargo.lock b/Cargo.lock
index f57123d69c4..15ffc6aaa46 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2169,6 +2169,7 @@ dependencies = [
  "rome_js_parser",
  "rome_js_semantic",
  "rome_js_syntax",
+ "rome_json_analyze",
  "rome_json_formatter",
  "rome_json_parser",
  "rome_json_syntax",
@@ -2867,9 +2868,9 @@ dependencies = [
 
 [[package]]
 name = "trybuild"
-version = "1.0.79"
+version = "1.0.80"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db3115bddce1b5f52dd4b5e0ec8298a66ce733e4cc6759247dc2d1c11508ec38"
+checksum = "501dbdbb99861e4ab6b60eb6a7493956a9defb644fd034bc4a5ef27c693c8a3a"
 dependencies = [
  "basic-toml",
  "glob",
diff --git a/crates/rome_cli/tests/commands/check.rs b/crates/rome_cli/tests/commands/check.rs
index e27e4cdbadb..2b23abba829 100644
--- a/crates/rome_cli/tests/commands/check.rs
+++ b/crates/rome_cli/tests/commands/check.rs
@@ -2398,3 +2398,46 @@ fn ignores_unknown_file() {
         result,
     ));
 }
+
+#[test]
+fn check_json_files() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let file_path1 = Path::new("test.json");
+    fs.insert(
+        file_path1.into(),
+        r#"{ "foo": true, "foo": true }"#.as_bytes(),
+    );
+
+    let configuration = Path::new("rome.json");
+    fs.insert(
+        configuration.into(),
+        r#"{
+	"linter": {
+		"rules": {
+			"nursery": {
+				"noDuplicateJsonKeys": "error"
+			}
+		}
+	}
+	 }"#
+        .as_bytes(),
+    );
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from(&[("check"), file_path1.as_os_str().to_str().unwrap()]),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "check_json_files",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/rome_cli/tests/snapshots/main_commands_check/check_json_files.snap b/crates/rome_cli/tests/snapshots/main_commands_check/check_json_files.snap
new file mode 100644
index 00000000000..bf6fd24809e
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_check/check_json_files.snap
@@ -0,0 +1,60 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `rome.json`
+
+```json
+{
+  "linter": {
+    "rules": {
+      "nursery": {
+        "noDuplicateJsonKeys": "error"
+      }
+    }
+  }
+}
+```
+
+## `test.json`
+
+```json
+{ "foo": true, "foo": true }
+```
+
+# Termination Message
+
+```block
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+test.json:1:3 lint/nursery/noDuplicateJsonKeys ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The key foo was already declared.
+  
+  > 1 │ { "foo": true, "foo": true }
+      │   ^^^^^
+  
+  i This where a duplicated key was declared again.
+  
+  > 1 │ { "foo": true, "foo": true }
+      │                ^^^^^
+  
+  i If a key is defined multiple times, only the last definition takes effect. Previous definitions are ignored.
+  
+
+```
+
+```block
+Checked 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/rome_deserialize/src/json.rs b/crates/rome_deserialize/src/json.rs
index af5dac500df..10cf927b4ad 100644
--- a/crates/rome_deserialize/src/json.rs
+++ b/crates/rome_deserialize/src/json.rs
@@ -15,7 +15,7 @@ pub trait JsonDeserialize: Sized {
     /// It accepts a JSON AST and a visitor. The visitor is the [default](Default) implementation of the data
     /// type that implements this trait.
     fn deserialize_from_ast(
-        root: JsonRoot,
+        root: &JsonRoot,
         visitor: &mut impl VisitJsonNode,
         diagnostics: &mut Vec<DeserializationDiagnostic>,
     ) -> Option<()>;
@@ -23,7 +23,7 @@ pub trait JsonDeserialize: Sized {
 
 impl JsonDeserialize for () {
     fn deserialize_from_ast(
-        _root: JsonRoot,
+        _root: &JsonRoot,
         _visitor: &mut impl VisitJsonNode,
         _diagnostics: &mut Vec<DeserializationDiagnostic>,
     ) -> Option<()> {
@@ -526,14 +526,14 @@ pub fn with_only_known_variants(
 ///         use rome_deserialize::Deserialized;
 ///         let mut output = Self::default();
 ///         let mut diagnostics = vec![];
-///         NewConfiguration::deserialize_from_ast(root, &mut output, &mut diagnostics);
+///         NewConfiguration::deserialize_from_ast(&root, &mut output, &mut diagnostics);
 ///         Deserialized::new(output, diagnostics)
 ///     }
 /// }
 ///
 ///
 /// impl JsonDeserialize for NewConfiguration {
-///     fn deserialize_from_ast(root: JsonRoot, visitor: &mut impl VisitJsonNode, diagnostics: &mut Vec<DeserializationDiagnostic>) -> Option<()> {
+///     fn deserialize_from_ast(root: &JsonRoot, visitor: &mut impl VisitJsonNode, diagnostics: &mut Vec<DeserializationDiagnostic>) -> Option<()> {
 ///         let object = root.value().ok()?;
 ///         let object = object.as_json_object_value()?;
 ///         for member in object.json_member_list() {
@@ -561,7 +561,7 @@ where
     let mut output = Output::default();
     let mut diagnostics = vec![];
     let parse = parse_json(source);
-    Output::deserialize_from_ast(parse.tree(), &mut output, &mut diagnostics);
+    Output::deserialize_from_ast(&parse.tree(), &mut output, &mut diagnostics);
     let mut errors = parse
         .into_diagnostics()
         .into_iter()
@@ -580,7 +580,7 @@ where
 }
 
 /// Attempts to deserialize a JSON AST, given the `Output`.
-pub fn deserialize_from_json_ast<Output>(parse: JsonRoot) -> Deserialized<Output>
+pub fn deserialize_from_json_ast<Output>(parse: &JsonRoot) -> Deserialized<Output>
 where
     Output: Default + VisitJsonNode + JsonDeserialize,
 {
diff --git a/crates/rome_diagnostics/Cargo.toml b/crates/rome_diagnostics/Cargo.toml
index f359e86f507..e8e4e44dd81 100644
--- a/crates/rome_diagnostics/Cargo.toml
+++ b/crates/rome_diagnostics/Cargo.toml
@@ -45,4 +45,4 @@ schema = ["schemars", "rome_text_edit/schemars", "rome_diagnostics_categories/sc
 
 [dev-dependencies]
 serde_json = "1.0.74"
-trybuild   = "1.0"
+trybuild   = "1.0.80"
diff --git a/crates/rome_service/Cargo.toml b/crates/rome_service/Cargo.toml
index 02e85cf2fe8..f940f25bb67 100644
--- a/crates/rome_service/Cargo.toml
+++ b/crates/rome_service/Cargo.toml
@@ -25,6 +25,7 @@ rome_js_formatter   = { workspace = true, features = ["serde"] }
 rome_js_parser      = { workspace = true }
 rome_js_semantic    = { workspace = true }
 rome_js_syntax      = { workspace = true, features = ["serde"] }
+rome_json_analyze   = { workspace = true }
 rome_json_formatter = { workspace = true }
 rome_json_parser    = { workspace = true }
 rome_json_syntax    = { workspace = true }
diff --git a/crates/rome_service/src/configuration/parse/json.rs b/crates/rome_service/src/configuration/parse/json.rs
index 7ad7f02e55b..0a1844d52be 100644
--- a/crates/rome_service/src/configuration/parse/json.rs
+++ b/crates/rome_service/src/configuration/parse/json.rs
@@ -18,7 +18,7 @@ use rome_rowan::AstNode;
 
 impl JsonDeserialize for Configuration {
     fn deserialize_from_ast(
-        root: JsonRoot,
+        root: &JsonRoot,
         visitor: &mut impl VisitJsonNode,
         diagnostics: &mut Vec<DeserializationDiagnostic>,
     ) -> Option<()> {
diff --git a/crates/rome_service/src/file_handlers/json.rs b/crates/rome_service/src/file_handlers/json.rs
index 1ef13b128b6..222c195bb4e 100644
--- a/crates/rome_service/src/file_handlers/json.rs
+++ b/crates/rome_service/src/file_handlers/json.rs
@@ -1,4 +1,5 @@
 use super::{ExtensionHandler, Mime};
+use crate::configuration::to_analyzer_configuration;
 use crate::file_handlers::{
     AnalyzerCapabilities, Capabilities, FixAllParams, FormatterCapabilities, LintParams,
     LintResults, ParserCapabilities,
@@ -11,16 +12,19 @@ use crate::workspace::{
     FixFileResult, GetSyntaxTreeResult, OrganizeImportsResult, PullActionsResult,
 };
 use crate::{Configuration, Rules, WorkspaceError};
+use rome_analyze::{AnalyzerOptions, ControlFlow, Never, RuleCategories};
 use rome_deserialize::json::deserialize_from_json_ast;
-use rome_diagnostics::{Diagnostic, Severity};
+use rome_diagnostics::{category, Diagnostic, DiagnosticExt, Severity};
 use rome_formatter::{FormatError, Printed};
 use rome_fs::{RomePath, CONFIG_NAME};
+use rome_json_analyze::analyze;
 use rome_json_formatter::context::JsonFormatOptions;
 use rome_json_formatter::format_node;
 use rome_json_syntax::{JsonFileSource, JsonLanguage, JsonRoot, JsonSyntaxNode};
 use rome_parser::AnyParse;
 use rome_rowan::{AstNode, FileSource, NodeCache};
 use rome_rowan::{TextRange, TextSize, TokenAtOffset};
+use std::path::PathBuf;
 
 impl Language for JsonLanguage {
     type FormatterSettings = ();
@@ -145,6 +149,7 @@ fn format(
     }
 }
 
+#[tracing::instrument(level = "debug", skip(parse))]
 fn format_range(
     rome_path: &RomePath,
     parse: AnyParse,
@@ -158,6 +163,7 @@ fn format_range(
     Ok(printed)
 }
 
+#[tracing::instrument(level = "debug", skip(parse))]
 fn format_on_type(
     rome_path: &RomePath,
     parse: AnyParse,
@@ -195,35 +201,96 @@ fn format_on_type(
 }
 
 fn lint(params: LintParams) -> LintResults {
-    let root: JsonRoot = params.parse.tree();
-    let mut diagnostics = params.parse.into_diagnostics();
+    tracing::debug_span!("lint").in_scope(move || {
+        let root: JsonRoot = params.parse.tree();
+        let mut diagnostics = params.parse.into_diagnostics();
+
+        // if we're parsing the `rome.json` file, we deserialize it, so we can emit diagnostics for
+        // malformed configuration
+        if params.path.ends_with(CONFIG_NAME) {
+            let deserialized = deserialize_from_json_ast::<Configuration>(&root);
+            diagnostics.extend(
+                deserialized
+                    .into_diagnostics()
+                    .into_iter()
+                    .map(rome_diagnostics::serde::Diagnostic::new)
+                    .collect::<Vec<_>>(),
+            );
+        }
+
+        let mut diagnostic_count = diagnostics.len() as u64;
+        let mut errors = diagnostics
+            .iter()
+            .filter(|diag| diag.severity() <= Severity::Error)
+            .count();
+
+        let skipped_diagnostics = diagnostic_count - diagnostics.len() as u64;
+
+        let has_lint = params.filter.categories.contains(RuleCategories::LINT);
+        let analyzer_options =
+            compute_analyzer_options(&params.settings, PathBuf::from(params.path.as_path()));
+
+        let (_, analyze_diagnostics) = analyze(
+            &root.value().unwrap(),
+            params.filter,
+            &analyzer_options,
+            |signal| {
+                if let Some(mut diagnostic) = signal.diagnostic() {
+                    // Do not report unused suppression comment diagnostics if this is a syntax-only analyzer pass
+                    if !has_lint && diagnostic.category() == Some(category!("suppressions/unused"))
+                    {
+                        return ControlFlow::<Never>::Continue(());
+                    }
+
+                    diagnostic_count += 1;
+
+                    // We do now check if the severity of the diagnostics should be changed.
+                    // The configuration allows to change the severity of the diagnostics emitted by rules.
+                    let severity = diagnostic
+                        .category()
+                        .filter(|category| category.name().starts_with("lint/"))
+                        .map(|category| {
+                            params
+                                .rules
+                                .and_then(|rules| rules.get_severity_from_code(category))
+                                .unwrap_or(Severity::Warning)
+                        })
+                        .unwrap_or_else(|| diagnostic.severity());
+
+                    if severity <= Severity::Error {
+                        errors += 1;
+                    }
+
+                    if diagnostic_count <= params.max_diagnostics {
+                        for action in signal.actions() {
+                            if !action.is_suppression() {
+                                diagnostic = diagnostic.add_code_suggestion(action.into());
+                            }
+                        }
+
+                        let error = diagnostic.with_severity(severity);
+
+                        diagnostics.push(rome_diagnostics::serde::Diagnostic::new(error));
+                    }
+                }
+
+                ControlFlow::<Never>::Continue(())
+            },
+        );
 
-    // if we're parsing the `rome.json` file, we deserialize it, so we can emit diagnostics for
-    // malformed configuration
-    if params.path.ends_with(CONFIG_NAME) {
-        let deserialized = deserialize_from_json_ast::<Configuration>(root);
         diagnostics.extend(
-            deserialized
-                .into_diagnostics()
+            analyze_diagnostics
                 .into_iter()
                 .map(rome_diagnostics::serde::Diagnostic::new)
                 .collect::<Vec<_>>(),
         );
-    }
-
-    let diagnostic_count = diagnostics.len() as u64;
-    let errors = diagnostics
-        .iter()
-        .filter(|diag| diag.severity() <= Severity::Error)
-        .count();
 
-    let skipped_diagnostics = diagnostic_count - diagnostics.len() as u64;
-
-    LintResults {
-        diagnostics,
-        errors,
-        skipped_diagnostics,
-    }
+        LintResults {
+            diagnostics,
+            errors,
+            skipped_diagnostics,
+        }
+    })
 }
 
 fn code_actions(
@@ -253,3 +320,15 @@ fn organize_imports(parse: AnyParse) -> Result<OrganizeImportsResult, WorkspaceE
         code: parse.syntax::<JsonLanguage>().to_string(),
     })
 }
+
+fn compute_analyzer_options(settings: &SettingsHandle, file_path: PathBuf) -> AnalyzerOptions {
+    let configuration = to_analyzer_configuration(
+        settings.as_ref().linter(),
+        &settings.as_ref().languages,
+        |_| vec![],
+    );
+    AnalyzerOptions {
+        configuration,
+        file_path,
+    }
+}
diff --git a/justfile b/justfile
index 41354a3d910..2b20a953ed3 100644
--- a/justfile
+++ b/justfile
@@ -94,7 +94,8 @@ ready:
   git diff --exit-code --quiet
   just codegen
   just documentation
+  just format
   cargo lint
-  cargo fmt
-  cargo test
+  just t
+  cargo test --doc
   git diff --exit-code --quiet