diff --git a/Cargo.toml b/Cargo.toml
index 1985afb3a61..138a7f74b94 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,6 +31,9 @@ rome_aria_metadata          = { path = "./crates/rome_aria_metadata" }
 rome_cli                    = { path = "./crates/rome_cli" }
 rome_console                = { version = "0.0.1", path = "./crates/rome_console" }
 rome_control_flow           = { path = "./crates/rome_control_flow" }
+rome_css_factory            = { path = "./crates/rome_css_factory" }
+rome_css_parser             = { path = "./crates/rome_css_parser" }
+rome_css_syntax             = { path = "./crates/rome_css_syntax" }
 rome_deserialize            = { version = "0.0.0", path = "./crates/rome_deserialize" }
 rome_diagnostics            = { version = "0.0.1", path = "./crates/rome_diagnostics" }
 rome_diagnostics_categories = { version = "0.0.1", path = "./crates/rome_diagnostics_categories" }
@@ -51,9 +54,6 @@ rome_json_factory           = { version = "0.0.1", path = "./crates/rome_json_fa
 rome_json_formatter         = { path = "./crates/rome_json_formatter" }
 rome_json_parser            = { path = "./crates/rome_json_parser" }
 rome_json_syntax            = { version = "0.0.1", path = "./crates/rome_json_syntax" }
-rome_css_factory            = { path = "./crates/rome_css_factory" }
-rome_css_parser             = { path = "./crates/rome_css_parser" }
-rome_css_syntax             = { path = "./crates/rome_css_syntax" }
 rome_lsp                    = { path = "./crates/rome_lsp" }
 rome_markup                 = { version = "0.0.1", path = "./crates/rome_markup" }
 rome_migrate                = { path = "./crates/rome_migrate" }
@@ -65,24 +65,24 @@ rome_text_size              = { version = "0.0.1", path = "./crates/rome_text_si
 tests_macros                = { path = "./crates/tests_macros" }
 
 # Crates needed in the workspace
+bitflags          = "2.3.1"
+bpaf              = { version = "0.9.2", features = ["derive"] }
+countme           = "3.0.1"
+dashmap           = "5.4.0"
+indexmap          = "1.9.3"
+insta             = "1.29.0"
+lazy_static       = "1.4.0"
+quickcheck        = "1.0.3"
 quickcheck_macros = "1.0.0"
-quickcheck  		  = "1.0.3"
-bitflags    		  = "2.3.1"
-bpaf        		  = { version = "0.9.2", features = ["derive"] }
-countme     		  = "3.0.1"
-dashmap     			= "5.4.0"
-indexmap    			= "1.9.3"
-insta       			= "1.29.0"
-lazy_static 			= "1.4.0"
-quote       			= { version = "1.0.28" }
-rustc-hash  			= "1.1.0"
-schemars    			= { version = "0.8.12" }
-serde       			= { version = "1.0.163", features = ["derive"], default-features = false }
-serde_json  			= "1.0.96"
-smallvec    			= { version = "1.10.0", features = ["union", "const_new"] }
-tracing     			= { version = "0.1.37", default-features = false, features = ["std"] }
+quote             = { version = "1.0.28" }
+rustc-hash        = "1.1.0"
+schemars          = { version = "0.8.12" }
+serde             = { version = "1.0.163", features = ["derive"], default-features = false }
+serde_json        = "1.0.96"
+smallvec          = { version = "1.10.0", features = ["union", "const_new"] }
+tracing           = { version = "0.1.37", default-features = false, features = ["std"] }
 # pinning to version 1.18 to avoid multiple versions of windows-sys as dependency
-tokio 						= { version = "~1.18.5" }
+tokio = { version = "~1.18.5" }
 
 
 [profile.dev.package.rome_wasm]
diff --git a/crates/rome_cli/src/execute/migrate.rs b/crates/rome_cli/src/execute/migrate.rs
index 513d4ad8551..576279dee23 100644
--- a/crates/rome_cli/src/execute/migrate.rs
+++ b/crates/rome_cli/src/execute/migrate.rs
@@ -3,6 +3,7 @@ use crate::{CliDiagnostic, CliSession};
 use rome_console::{markup, ConsoleExt};
 use rome_diagnostics::{category, PrintDiagnostic};
 use rome_fs::OpenOptions;
+use rome_json_parser::JsonParserOptions;
 use rome_json_syntax::JsonRoot;
 use rome_migrate::{migrate_configuration, ControlFlow};
 use rome_rowan::AstNode;
@@ -26,7 +27,7 @@ pub(crate) fn run(
         fs.open_with_options(configuration_path.as_path(), open_options)?;
     let mut configuration_content = String::new();
     configuration_file.read_to_string(&mut configuration_content)?;
-    let parsed = rome_json_parser::parse_json(&configuration_content);
+    let parsed = rome_json_parser::parse_json(&configuration_content, JsonParserOptions::default());
     let mut errors = 0;
     let mut tree = parsed.tree();
     let mut actions = Vec::new();
diff --git a/crates/rome_cli/src/execute/traverse.rs b/crates/rome_cli/src/execute/traverse.rs
index 38a711a9d04..221d045816a 100644
--- a/crates/rome_cli/src/execute/traverse.rs
+++ b/crates/rome_cli/src/execute/traverse.rs
@@ -62,7 +62,6 @@ pub(crate) fn traverse(
     inputs: Vec<OsString>,
 ) -> Result<(), CliDiagnostic> {
     init_thread_pool();
-
     if inputs.is_empty() && execution.as_stdin_file().is_none() {
         return Err(CliDiagnostic::missing_argument(
             "<INPUT>",
diff --git a/crates/rome_cli/tests/commands/format.rs b/crates/rome_cli/tests/commands/format.rs
index d09b870edb6..4091095bac5 100644
--- a/crates/rome_cli/tests/commands/format.rs
+++ b/crates/rome_cli/tests/commands/format.rs
@@ -1839,3 +1839,40 @@ fn doesnt_error_if_no_files_were_processed() {
         result,
     ));
 }
+
+#[test]
+fn ignore_comments_error_when_allow_comments() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let config_json = r#"{
+  "json": {
+    "parser": { "allowComments": true }
+  }
+}
+
+	"#;
+    let rome_config = "rome.json";
+    let code = r#"
+/*test*/ [1, 2, 3]
+	"#;
+    let file_path = Path::new("tsconfig.json");
+    fs.insert(file_path.into(), code.as_bytes());
+    fs.insert(rome_config.into(), config_json);
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from([("format"), file_path.as_os_str().to_str().unwrap()].as_slice()),
+    );
+
+    // assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "ignore_comments_error_when_allow_comments",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/rome_cli/tests/commands/init.rs b/crates/rome_cli/tests/commands/init.rs
index fd217a937b1..730ca275605 100644
--- a/crates/rome_cli/tests/commands/init.rs
+++ b/crates/rome_cli/tests/commands/init.rs
@@ -5,7 +5,7 @@ use bpaf::Args;
 use rome_console::BufferConsole;
 use rome_fs::{FileSystemExt, MemoryFileSystem};
 use rome_json_formatter::context::JsonFormatOptions;
-use rome_json_parser::parse_json;
+use rome_json_parser::{parse_json, JsonParserOptions};
 use rome_service::DynRef;
 use std::path::Path;
 
@@ -52,7 +52,7 @@ fn creates_config_file() {
     let mut content = String::new();
     file.read_to_string(&mut content)
         .expect("failed to read file from memory FS");
-    let parsed = parse_json(CONFIG_INIT_DEFAULT);
+    let parsed = parse_json(CONFIG_INIT_DEFAULT, JsonParserOptions::default());
     let formatted =
         rome_json_formatter::format_node(JsonFormatOptions::default(), &parsed.syntax())
             .expect("valid format document")
@@ -95,7 +95,10 @@ fn creates_config_file_when_rome_installed_via_package_manager() {
     let mut content = String::new();
     file.read_to_string(&mut content)
         .expect("failed to read file from memory FS");
-    let parsed = parse_json(CONFIG_INIT_DEFAULT_WHEN_INSTALLED);
+    let parsed = parse_json(
+        CONFIG_INIT_DEFAULT_WHEN_INSTALLED,
+        JsonParserOptions::default(),
+    );
     let formatted =
         rome_json_formatter::format_node(JsonFormatOptions::default(), &parsed.syntax())
             .expect("valid format document")
diff --git a/crates/rome_cli/tests/snap_test.rs b/crates/rome_cli/tests/snap_test.rs
index 3807271d174..d2cfcd958e1 100644
--- a/crates/rome_cli/tests/snap_test.rs
+++ b/crates/rome_cli/tests/snap_test.rs
@@ -7,7 +7,7 @@ use rome_formatter::IndentStyle;
 use rome_fs::{FileSystemExt, MemoryFileSystem};
 use rome_json_formatter::context::JsonFormatOptions;
 use rome_json_formatter::format_node;
-use rome_json_parser::parse_json;
+use rome_json_parser::{parse_json, JsonParserOptions};
 use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::env::{current_exe, temp_dir};
@@ -49,7 +49,10 @@ impl CliSnapshot {
         let mut content = String::new();
 
         if let Some(configuration) = &self.configuration {
-            let parsed = parse_json(&redact_snapshot(configuration));
+            let parsed = parse_json(
+                &redact_snapshot(configuration),
+                JsonParserOptions::default(),
+            );
             let formatted = format_node(
                 JsonFormatOptions::default().with_indent_style(IndentStyle::Space(2)),
                 &parsed.syntax(),
diff --git a/crates/rome_cli/tests/snapshots/main_commands_format/ignore_comments_error_when_allow_comments.snap b/crates/rome_cli/tests/snapshots/main_commands_format/ignore_comments_error_when_allow_comments.snap
new file mode 100644
index 00000000000..8533db6ebd7
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_format/ignore_comments_error_when_allow_comments.snap
@@ -0,0 +1,52 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `rome.json`
+
+```json
+{
+  "json": {
+    "parser": { "allowComments": true }
+  }
+}
+```
+
+## `tsconfig.json`
+
+```json
+
+/*test*/ [1, 2, 3]
+	
+```
+
+# Termination Message
+
+```block
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × No files were processed in the specified paths.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+tsconfig.json format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Format with errors is disabled.
+  
+
+```
+
+```block
+Compared 1 file(s) in <TIME>
+```
+
+```block
+Skipped 1 file(s)
+```
+
+
diff --git a/crates/rome_css_parser/Cargo.toml b/crates/rome_css_parser/Cargo.toml
index f9c2b27c172..44fa3c75c83 100644
--- a/crates/rome_css_parser/Cargo.toml
+++ b/crates/rome_css_parser/Cargo.toml
@@ -12,9 +12,9 @@ version              = "0.0.1"
 
 [dependencies]
 rome_console          = { workspace = true }
+rome_css_syntax       = { workspace = true }
 rome_diagnostics      = { workspace = true }
 rome_js_unicode_table = { workspace = true }
-rome_css_syntax       = { workspace = true }
 rome_parser           = { workspace = true }
 rome_rowan            = { workspace = true }
 tracing               = { workspace = true }
diff --git a/crates/rome_deserialize/src/json.rs b/crates/rome_deserialize/src/json.rs
index 10cf927b4ad..7e2a5864af4 100644
--- a/crates/rome_deserialize/src/json.rs
+++ b/crates/rome_deserialize/src/json.rs
@@ -2,7 +2,7 @@ use crate::{DeserializationDiagnostic, Deserialized, VisitNode};
 use indexmap::IndexSet;
 use rome_console::markup;
 use rome_diagnostics::{DiagnosticExt, Error};
-use rome_json_parser::parse_json;
+use rome_json_parser::{parse_json, JsonParserOptions};
 use rome_json_syntax::{
     AnyJsonValue, JsonArrayValue, JsonBooleanValue, JsonLanguage, JsonMemberName, JsonNumberValue,
     JsonObjectValue, JsonRoot, JsonStringValue, JsonSyntaxNode,
@@ -560,7 +560,7 @@ where
 {
     let mut output = Output::default();
     let mut diagnostics = vec![];
-    let parse = parse_json(source);
+    let parse = parse_json(source, JsonParserOptions::default());
     Output::deserialize_from_ast(&parse.tree(), &mut output, &mut diagnostics);
     let mut errors = parse
         .into_diagnostics()
diff --git a/crates/rome_json_analyze/src/lib.rs b/crates/rome_json_analyze/src/lib.rs
index 97b71e61005..2750196b964 100644
--- a/crates/rome_json_analyze/src/lib.rs
+++ b/crates/rome_json_analyze/src/lib.rs
@@ -103,7 +103,7 @@ mod tests {
     use rome_console::{markup, Markup};
     use rome_diagnostics::termcolor::NoColor;
     use rome_diagnostics::{Diagnostic, DiagnosticExt, PrintDiagnostic, Severity};
-    use rome_json_parser::parse_json;
+    use rome_json_parser::{parse_json, JsonParserOptions};
     use rome_json_syntax::TextRange;
     use std::slice;
 
@@ -130,7 +130,7 @@ mod tests {
 }
 "#;
 
-        let parsed = parse_json(SOURCE);
+        let parsed = parse_json(SOURCE, JsonParserOptions::default());
 
         let mut error_ranges: Vec<TextRange> = Vec::new();
         let rule_filter = RuleFilter::Rule("nursery", "noDuplicateKeys");
diff --git a/crates/rome_json_analyze/tests/spec_tests.rs b/crates/rome_json_analyze/tests/spec_tests.rs
index a56ded400c0..af746f24f30 100644
--- a/crates/rome_json_analyze/tests/spec_tests.rs
+++ b/crates/rome_json_analyze/tests/spec_tests.rs
@@ -9,7 +9,7 @@ use rome_deserialize::json::deserialize_from_json_str;
 use rome_diagnostics::advice::CodeSuggestionAdvice;
 use rome_diagnostics::termcolor::{Buffer, NoColor};
 use rome_diagnostics::{DiagnosticExt, Error, PrintDiagnostic, Severity};
-use rome_json_parser::{parse_json, JsonParse};
+use rome_json_parser::{parse_json, JsonParse, JsonParserOptions};
 use rome_json_syntax::{JsonLanguage, JsonSyntaxNode};
 use rome_rowan::SyntaxKind;
 use rome_rowan::SyntaxSlot;
@@ -77,7 +77,7 @@ pub(crate) fn write_analysis_to_snapshot(
     file_name: &str,
     input_file: &Path,
 ) -> usize {
-    let parsed = parse_json(input_code);
+    let parsed = parse_json(input_code, JsonParserOptions::default());
     let root = parsed.tree();
 
     let mut diagnostics = Vec::new();
@@ -236,7 +236,7 @@ fn check_code_action(path: &Path, source: &str, action: &AnalyzerAction<JsonLang
     }
 
     // Re-parse the modified code and panic if the resulting tree has syntax errors
-    let re_parse = parse_json(&output);
+    let re_parse = parse_json(&output, JsonParserOptions::default());
     assert_errors_are_absent(&re_parse, path);
 }
 
diff --git a/crates/rome_json_formatter/src/lib.rs b/crates/rome_json_formatter/src/lib.rs
index 89070a1cc15..2ea9e1bcc1b 100644
--- a/crates/rome_json_formatter/src/lib.rs
+++ b/crates/rome_json_formatter/src/lib.rs
@@ -290,9 +290,10 @@ pub fn format_sub_tree(options: JsonFormatOptions, root: &JsonSyntaxNode) -> For
 
 #[cfg(test)]
 mod tests {
+
     use crate::context::JsonFormatOptions;
     use crate::format_node;
-    use rome_json_parser::parse_json;
+    use rome_json_parser::{parse_json, JsonParserOptions};
 
     #[test]
     fn smoke_test() {
@@ -305,7 +306,7 @@ mod tests {
     "e": false
 }
 "#;
-        let parse = parse_json(src);
+        let parse = parse_json(src, JsonParserOptions::default());
         let options = JsonFormatOptions::default();
         let formatted = format_node(options, &parse.syntax()).unwrap();
         assert_eq!(
diff --git a/crates/rome_json_formatter/tests/language.rs b/crates/rome_json_formatter/tests/language.rs
index 4c60441a30c..38fedeaf9e5 100644
--- a/crates/rome_json_formatter/tests/language.rs
+++ b/crates/rome_json_formatter/tests/language.rs
@@ -2,14 +2,16 @@ use rome_formatter::{FormatContext, FormatResult, Formatted, IndentStyle, LineWi
 use rome_formatter_test::TestFormatLanguage;
 use rome_json_formatter::context::{JsonFormatContext, JsonFormatOptions};
 use rome_json_formatter::{format_node, format_range, JsonFormatLanguage};
-use rome_json_parser::parse_json;
+use rome_json_parser::{parse_json, JsonParserOptions};
 use rome_json_syntax::{JsonFileSource, JsonLanguage};
 use rome_parser::AnyParse;
 use rome_rowan::{FileSource, SyntaxNode, TextRange};
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct JsonTestFormatLanguage;
+pub struct JsonTestFormatLanguage {
+    source_type: JsonFileSource,
+}
 
 impl TestFormatLanguage for JsonTestFormatLanguage {
     type SyntaxLanguage = JsonLanguage;
@@ -18,11 +20,12 @@ impl TestFormatLanguage for JsonTestFormatLanguage {
     type FormatLanguage = JsonFormatLanguage;
 
     fn parse(&self, text: &str) -> AnyParse {
-        let parse = parse_json(text);
+        let parse = parse_json(text, JsonParserOptions::default());
+
         AnyParse::new(
             parse.syntax().as_send().unwrap(),
             parse.into_diagnostics(),
-            JsonFileSource::json().as_any_file_source(),
+            self.source_type.as_any_file_source(),
         )
     }
 
diff --git a/crates/rome_json_formatter/tests/quick_test.rs b/crates/rome_json_formatter/tests/quick_test.rs
index 7bd0a964782..0286f31d3bc 100644
--- a/crates/rome_json_formatter/tests/quick_test.rs
+++ b/crates/rome_json_formatter/tests/quick_test.rs
@@ -1,7 +1,7 @@
 use rome_formatter_test::check_reformat::CheckReformat;
 use rome_json_formatter::context::JsonFormatOptions;
 use rome_json_formatter::format_node;
-use rome_json_parser::parse_json;
+use rome_json_parser::{parse_json, JsonParserOptions};
 
 mod language {
     include!("language.rs");
@@ -27,7 +27,7 @@ fn quick_test() {
     ]
   }
 "#;
-    let parse = parse_json(src);
+    let parse = parse_json(src, JsonParserOptions::default());
     let options = JsonFormatOptions::default();
     let result = format_node(options.clone(), &parse.syntax())
         .unwrap()
diff --git a/crates/rome_json_parser/src/lexer/mod.rs b/crates/rome_json_parser/src/lexer/mod.rs
index 95cc27c5362..7775931bce2 100644
--- a/crates/rome_json_parser/src/lexer/mod.rs
+++ b/crates/rome_json_parser/src/lexer/mod.rs
@@ -9,6 +9,8 @@ use rome_parser::diagnostic::ParseDiagnostic;
 use std::iter::FusedIterator;
 use std::ops::Add;
 
+use crate::JsonParserOptions;
+
 pub struct Token {
     kind: JsonSyntaxKind,
     range: TextRange,
@@ -34,6 +36,7 @@ pub(crate) struct Lexer<'src> {
     position: usize,
 
     diagnostics: Vec<ParseDiagnostic>,
+    config: JsonParserOptions,
 }
 
 impl<'src> Lexer<'src> {
@@ -43,6 +46,7 @@ impl<'src> Lexer<'src> {
             source: string,
             position: 0,
             diagnostics: vec![],
+            config: JsonParserOptions::default(),
         }
     }
 
@@ -695,10 +699,12 @@ impl<'src> Lexer<'src> {
                         b'*' if self.peek_byte() == Some(b'/') => {
                             self.advance(2);
 
-                            self.diagnostics.push(ParseDiagnostic::new(
-                                "JSON standard does not allow comments.",
-                                start..self.text_position(),
-                            ));
+                            if !self.config.allow_comments {
+                                self.diagnostics.push(ParseDiagnostic::new(
+                                    "JSON standard does not allow comments.",
+                                    start..self.text_position(),
+                                ));
+                            }
 
                             if has_newline {
                                 return MULTILINE_COMMENT;
@@ -739,16 +745,23 @@ impl<'src> Lexer<'src> {
                     }
                 }
 
-                self.diagnostics.push(ParseDiagnostic::new(
-                    "JSON standard does not allow comments.",
-                    start..self.text_position(),
-                ));
+                if !self.config.allow_comments {
+                    self.diagnostics.push(ParseDiagnostic::new(
+                        "JSON standard does not allow comments.",
+                        start..self.text_position(),
+                    ));
+                }
 
                 COMMENT
             }
             _ => self.eat_unexpected_character(),
         }
     }
+
+    pub(crate) fn with_config(mut self, config: JsonParserOptions) -> Self {
+        self.config = config;
+        self
+    }
 }
 
 impl Iterator for Lexer<'_> {
diff --git a/crates/rome_json_parser/src/lib.rs b/crates/rome_json_parser/src/lib.rs
index 26b3dee8c77..980240fb9f2 100644
--- a/crates/rome_json_parser/src/lib.rs
+++ b/crates/rome_json_parser/src/lib.rs
@@ -2,6 +2,7 @@
 
 use crate::parser::JsonParser;
 use crate::syntax::parse_root;
+pub use parser::JsonParserOptions;
 use rome_json_factory::JsonSyntaxFactory;
 use rome_json_syntax::{JsonLanguage, JsonRoot, JsonSyntaxNode};
 pub use rome_parser::prelude::*;
@@ -17,15 +18,19 @@ mod token_source;
 pub(crate) type JsonLosslessTreeSink<'source> =
     LosslessTreeSink<'source, JsonLanguage, JsonSyntaxFactory>;
 
-pub fn parse_json(source: &str) -> JsonParse {
+pub fn parse_json(source: &str, options: JsonParserOptions) -> JsonParse {
     let mut cache = NodeCache::default();
-    parse_json_with_cache(source, &mut cache)
+    parse_json_with_cache(source, &mut cache, options)
 }
 
 /// Parses the provided string as JSON program using the provided node cache.
-pub fn parse_json_with_cache(source: &str, cache: &mut NodeCache) -> JsonParse {
+pub fn parse_json_with_cache(
+    source: &str,
+    cache: &mut NodeCache,
+    config: JsonParserOptions,
+) -> JsonParse {
     tracing::debug_span!("parse").in_scope(move || {
-        let mut parser = JsonParser::new(source);
+        let mut parser = JsonParser::new(source, config);
 
         parse_root(&mut parser);
 
@@ -60,7 +65,8 @@ impl JsonParse {
     ///
     /// # fn main() -> Result<(), SyntaxError> {
     /// use rome_json_syntax::JsonSyntaxKind;
-    /// let parse = parse_json(r#"["a", 1]"#);
+    /// use rome_json_parser::JsonParserOptions;
+    /// let parse = parse_json(r#"["a", 1]"#, JsonParserOptions::default());
     ///
     /// // Get the root value
     /// let root_value = parse.tree().value()?;
diff --git a/crates/rome_json_parser/src/parser.rs b/crates/rome_json_parser/src/parser.rs
index 870bc5273df..02a3eed26ff 100644
--- a/crates/rome_json_parser/src/parser.rs
+++ b/crates/rome_json_parser/src/parser.rs
@@ -1,6 +1,6 @@
 use crate::token_source::JsonTokenSource;
 use rome_json_syntax::JsonSyntaxKind;
-use rome_parser::diagnostic::merge_diagnostics;
+use rome_parser::diagnostic::{expected_token, merge_diagnostics};
 use rome_parser::event::Event;
 use rome_parser::prelude::*;
 use rome_parser::token_source::Trivia;
@@ -9,13 +9,20 @@ use rome_parser::ParserContext;
 pub(crate) struct JsonParser<'source> {
     context: ParserContext<JsonSyntaxKind>,
     source: JsonTokenSource<'source>,
+    config: JsonParserOptions,
+}
+
+#[derive(Default, Debug, Clone, Copy)]
+pub struct JsonParserOptions {
+    pub allow_comments: bool,
 }
 
 impl<'source> JsonParser<'source> {
-    pub fn new(source: &'source str) -> Self {
+    pub fn new(source: &'source str, config: JsonParserOptions) -> Self {
         Self {
             context: ParserContext::default(),
-            source: JsonTokenSource::from_str(source),
+            source: JsonTokenSource::from_str(source, config),
+            config,
         }
     }
 
@@ -54,4 +61,26 @@ impl<'source> Parser for JsonParser<'source> {
     fn source_mut(&mut self) -> &mut Self::Source {
         &mut self.source
     }
+
+    /// Try to eat a specific token kind, if the kind is not there then adds an error to the events stack.
+    fn expect(&mut self, kind: Self::Kind) -> bool {
+        if self.eat(kind) {
+            true
+        } else {
+            if self.config.allow_comments {
+                while matches!(
+                    self.cur(),
+                    JsonSyntaxKind::COMMENT | JsonSyntaxKind::MULTILINE_COMMENT
+                ) {
+                    self.bump_any();
+                }
+            }
+            if self.eat(kind) {
+                return true;
+            }
+
+            self.error(expected_token(kind));
+            false
+        }
+    }
 }
diff --git a/crates/rome_json_parser/src/token_source.rs b/crates/rome_json_parser/src/token_source.rs
index b2fd0fa8338..4d1c4546fac 100644
--- a/crates/rome_json_parser/src/token_source.rs
+++ b/crates/rome_json_parser/src/token_source.rs
@@ -1,4 +1,5 @@
 use crate::lexer::Lexer;
+use crate::JsonParserOptions;
 use rome_json_syntax::JsonSyntaxKind::{EOF, TOMBSTONE};
 use rome_json_syntax::{JsonSyntaxKind, TextRange};
 use rome_parser::diagnostic::ParseDiagnostic;
@@ -12,11 +13,12 @@ pub(crate) struct JsonTokenSource<'source> {
     current: JsonSyntaxKind,
     current_range: TextRange,
     preceding_line_break: bool,
+    config: JsonParserOptions,
 }
 
 impl<'source> JsonTokenSource<'source> {
-    pub fn from_str(source: &'source str) -> Self {
-        let lexer = Lexer::from_str(source);
+    pub fn from_str(source: &'source str, config: JsonParserOptions) -> Self {
+        let lexer = Lexer::from_str(source).with_config(config);
 
         let mut source = Self {
             lexer,
@@ -24,6 +26,7 @@ impl<'source> JsonTokenSource<'source> {
             current: TOMBSTONE,
             current_range: TextRange::default(),
             preceding_line_break: false,
+            config,
         };
 
         source.next_non_trivia_token(true);
@@ -39,6 +42,17 @@ impl<'source> JsonTokenSource<'source> {
 
             match trivia_kind {
                 Err(_) => {
+                    if self.config.allow_comments && token.kind().is_comments() {
+                        let trivia_kind = match token.kind() {
+                            JsonSyntaxKind::COMMENT => TriviaPieceKind::SingleLineComment,
+                            JsonSyntaxKind::MULTILINE_COMMENT => TriviaPieceKind::MultiLineComment,
+                            _ => unreachable!(),
+                        };
+                        self.trivia
+                            .push(Trivia::new(trivia_kind, token.range(), trailing));
+                        continue;
+                    }
+
                     self.current = token.kind();
                     self.current_range = token.range();
 
diff --git a/crates/rome_json_parser/tests/json_test_suite/allow_comments/basic.json b/crates/rome_json_parser/tests/json_test_suite/allow_comments/basic.json
new file mode 100644
index 00000000000..700cb8e4111
--- /dev/null
+++ b/crates/rome_json_parser/tests/json_test_suite/allow_comments/basic.json
@@ -0,0 +1 @@
+/*leading*/ [1,true] // trivial
diff --git a/crates/rome_json_parser/tests/json_test_suite/allow_comments/basic.json.snap b/crates/rome_json_parser/tests/json_test_suite/allow_comments/basic.json.snap
new file mode 100644
index 00000000000..9244bff5c10
--- /dev/null
+++ b/crates/rome_json_parser/tests/json_test_suite/allow_comments/basic.json.snap
@@ -0,0 +1,52 @@
+---
+source: crates/rome_json_parser/tests/spec_test.rs
+expression: snapshot
+---
+
+## Input
+
+```json
+/*leading*/ [1,true] // trivial
+
+```
+
+
+## AST
+
+```
+JsonRoot {
+    value: JsonArrayValue {
+        l_brack_token: L_BRACK@0..13 "[" [Comments("/*leading*/"), Whitespace(" ")] [],
+        elements: JsonArrayElementList [
+            JsonNumberValue {
+                value_token: JSON_NUMBER_LITERAL@13..14 "1" [] [],
+            },
+            COMMA@14..15 "," [] [],
+            JsonBooleanValue {
+                value_token: TRUE_KW@15..19 "true" [] [],
+            },
+        ],
+        r_brack_token: R_BRACK@19..31 "]" [] [Whitespace(" "), Comments("// trivial")],
+    },
+    eof_token: EOF@31..32 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JSON_ROOT@0..32
+  0: JSON_ARRAY_VALUE@0..31
+    0: L_BRACK@0..13 "[" [Comments("/*leading*/"), Whitespace(" ")] []
+    1: JSON_ARRAY_ELEMENT_LIST@13..19
+      0: JSON_NUMBER_VALUE@13..14
+        0: JSON_NUMBER_LITERAL@13..14 "1" [] []
+      1: COMMA@14..15 "," [] []
+      2: JSON_BOOLEAN_VALUE@15..19
+        0: TRUE_KW@15..19 "true" [] []
+    2: R_BRACK@19..31 "]" [] [Whitespace(" "), Comments("// trivial")]
+  1: EOF@31..32 "" [Newline("\n")] []
+
+```
+
+
diff --git a/crates/rome_json_parser/tests/spec_test.rs b/crates/rome_json_parser/tests/spec_test.rs
index 43486932118..d6983de3b12 100644
--- a/crates/rome_json_parser/tests/spec_test.rs
+++ b/crates/rome_json_parser/tests/spec_test.rs
@@ -3,7 +3,7 @@ use rome_console::markup;
 use rome_diagnostics::display::PrintDiagnostic;
 use rome_diagnostics::termcolor;
 use rome_diagnostics::DiagnosticExt;
-use rome_json_parser::parse_json;
+use rome_json_parser::{parse_json, JsonParserOptions};
 use rome_rowan::SyntaxKind;
 use std::fmt::Write;
 use std::fs;
@@ -16,12 +16,13 @@ pub enum ExpectedOutcome {
     Undefined,
 }
 
-pub fn run(test_case: &str, _snapshot_name: &str, test_directory: &str, outcome: &str) {
-    let outcome = match outcome {
+pub fn run(test_case: &str, _snapshot_name: &str, test_directory: &str, outcome_str: &str) {
+    let outcome = match outcome_str {
         "ok" => ExpectedOutcome::Pass,
         "error" => ExpectedOutcome::Fail,
         "undefined" => ExpectedOutcome::Undefined,
-        _ => panic!("Invalid expected outcome {outcome}"),
+        "allow_comments" => ExpectedOutcome::Pass,
+        _ => panic!("Invalid expected outcome {outcome_str}"),
     };
 
     let test_case_path = Path::new(test_case);
@@ -35,7 +36,10 @@ pub fn run(test_case: &str, _snapshot_name: &str, test_directory: &str, outcome:
     let content = fs::read_to_string(test_case_path)
         .expect("Expected test path to be a readable file in UTF8 encoding");
 
-    let parsed = parse_json(&content);
+    let parse_conifg = JsonParserOptions {
+        allow_comments: outcome_str == "allow_comments",
+    };
+    let parsed = parse_json(&content, parse_conifg);
     let formatted_ast = format!("{:#?}", parsed.tree());
 
     let mut snapshot = String::new();
diff --git a/crates/rome_json_parser/tests/spec_tests.rs b/crates/rome_json_parser/tests/spec_tests.rs
index 27cc3c11d4f..e7322bdcdf7 100644
--- a/crates/rome_json_parser/tests/spec_tests.rs
+++ b/crates/rome_json_parser/tests/spec_tests.rs
@@ -16,3 +16,8 @@ mod undefined {
     //! parsers are free to accept or reject content
     tests_macros::gen_tests! {"tests/json_test_suite/undefined/*.json", crate::spec_test::run, "undefined"}
 }
+
+mod allow_comments {
+    //! Tests should pass even with comments in json
+    tests_macros::gen_tests! {"tests/json_test_suite/allow_comments/*.json", crate::spec_test::run, "allow_comments"}
+}
diff --git a/crates/rome_json_syntax/src/lib.rs b/crates/rome_json_syntax/src/lib.rs
index 12d148db7b6..9d8790cbb9c 100644
--- a/crates/rome_json_syntax/src/lib.rs
+++ b/crates/rome_json_syntax/src/lib.rs
@@ -30,6 +30,13 @@ impl JsonSyntaxKind {
         matches!(self, JsonSyntaxKind::NEWLINE | JsonSyntaxKind::WHITESPACE)
     }
 
+    pub fn is_comments(self) -> bool {
+        matches!(
+            self,
+            JsonSyntaxKind::COMMENT | JsonSyntaxKind::MULTILINE_COMMENT
+        )
+    }
+
     #[inline]
     pub const fn is_keyword(self) -> bool {
         matches!(self, T![null] | T![true] | T![false])
diff --git a/crates/rome_migrate/src/lib.rs b/crates/rome_migrate/src/lib.rs
index 65953d6f527..5ac0474b91e 100644
--- a/crates/rome_migrate/src/lib.rs
+++ b/crates/rome_migrate/src/lib.rs
@@ -97,7 +97,7 @@ where
 mod test {
     use crate::migrate_configuration;
     use rome_analyze::{ControlFlow, Never};
-    use rome_json_parser::parse_json;
+    use rome_json_parser::{parse_json, JsonParserOptions};
     use std::path::Path;
 
     #[test]
@@ -105,7 +105,7 @@ mod test {
     fn smoke() {
         let source = r#"{ "something": "else" }"#;
 
-        let parsed = parse_json(source);
+        let parsed = parse_json(source, JsonParserOptions::default());
 
         migrate_configuration(&parsed.tree().value().unwrap(), Path::new(""), |signal| {
             for action in signal.actions() {
diff --git a/crates/rome_service/src/configuration/javascript.rs b/crates/rome_service/src/configuration/javascript.rs
index 20a1c52e179..b3391b162f8 100644
--- a/crates/rome_service/src/configuration/javascript.rs
+++ b/crates/rome_service/src/configuration/javascript.rs
@@ -54,7 +54,7 @@ impl MergeWith<Option<JavascriptFormatter>> for JavascriptConfiguration {
 
 impl JavascriptConfiguration {
     pub(crate) const KNOWN_KEYS: &'static [&'static str] =
-        &["formatter", "globals", "organizeImports"];
+        &["formatter", "globals", "organizeImports", "parser"];
 
     pub fn with_formatter() -> Self {
         Self {
diff --git a/crates/rome_service/src/configuration/json.rs b/crates/rome_service/src/configuration/json.rs
new file mode 100644
index 00000000000..bd52ee9b71d
--- /dev/null
+++ b/crates/rome_service/src/configuration/json.rs
@@ -0,0 +1,52 @@
+use crate::configuration::merge::MergeWith;
+use bpaf::Bpaf;
+use serde::{Deserialize, Serialize};
+
+#[derive(Default, Debug, Deserialize, Serialize, Eq, PartialEq, Clone, Bpaf)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[serde(default, deny_unknown_fields)]
+pub struct JsonConfiguration {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[bpaf(external(json_parser), optional)]
+    pub parser: Option<JsonParser>,
+}
+
+impl JsonConfiguration {
+    pub const KNOWN_KEYS: &'static [&'static str] = &["parser"];
+}
+
+impl MergeWith<JsonConfiguration> for JsonConfiguration {
+    fn merge_with(&mut self, other: JsonConfiguration) {
+        if let Some(other_parser) = other.parser {
+            let parser = self.parser.get_or_insert_with(JsonParser::default);
+            parser.merge_with(other_parser);
+        }
+    }
+}
+
+#[derive(Debug, Default, Deserialize, Serialize, Eq, PartialEq, Clone, Bpaf)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[serde(default, deny_unknown_fields)]
+pub struct JavascriptOrganizeImports {}
+
+#[derive(Default, Debug, Deserialize, Serialize, Eq, PartialEq, Clone, Bpaf)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase", default, deny_unknown_fields)]
+pub struct JsonParser {
+    #[bpaf(hide)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Allow parsing comments in `.json` files
+    pub allow_comments: Option<bool>,
+}
+
+impl JsonParser {
+    pub(crate) const KNOWN_KEYS: &'static [&'static str] = &["allowComments"];
+}
+
+impl MergeWith<JsonParser> for JsonParser {
+    fn merge_with(&mut self, other: JsonParser) {
+        if let Some(allow_comments) = other.allow_comments {
+            self.allow_comments = Some(allow_comments);
+        }
+    }
+}
diff --git a/crates/rome_service/src/configuration/mod.rs b/crates/rome_service/src/configuration/mod.rs
index c6fe15b32e3..93848330826 100644
--- a/crates/rome_service/src/configuration/mod.rs
+++ b/crates/rome_service/src/configuration/mod.rs
@@ -2,20 +2,11 @@
 //!
 //! The configuration is divided by "tool", and then it's possible to further customise it
 //! by language. The language might further options divided by tool.
-
-use crate::{DynRef, WorkspaceError, VERSION};
-use bpaf::Bpaf;
-use rome_fs::{AutoSearchResult, FileSystem, OpenOptions};
-use serde::{Deserialize, Serialize};
-use std::fmt::Debug;
-use std::io::ErrorKind;
-use std::num::NonZeroU64;
-use std::path::{Path, PathBuf};
-
 pub mod diagnostics;
 pub mod formatter;
 mod generated;
 pub mod javascript;
+pub mod json;
 pub mod linter;
 mod merge;
 pub mod organize_imports;
@@ -30,15 +21,24 @@ use crate::configuration::organize_imports::{organize_imports, OrganizeImports};
 pub use crate::configuration::string_set::StringSet;
 use crate::configuration::vcs::{vcs_configuration, VcsConfiguration};
 use crate::settings::{LanguagesSettings, LinterSettings};
+use crate::{DynRef, WorkspaceError, VERSION};
+use bpaf::Bpaf;
 pub use formatter::{formatter_configuration, FormatterConfiguration, PlainIndentStyle};
 pub use javascript::{javascript_configuration, JavascriptConfiguration, JavascriptFormatter};
+pub use json::{json_configuration, JsonConfiguration};
 pub use linter::{linter_configuration, LinterConfiguration, RuleConfiguration, Rules};
 use rome_analyze::{AnalyzerConfiguration, AnalyzerRules};
 use rome_deserialize::json::deserialize_from_json_str;
 use rome_deserialize::Deserialized;
+use rome_fs::{AutoSearchResult, FileSystem, OpenOptions};
 use rome_js_analyze::metadata;
 use rome_json_formatter::context::JsonFormatOptions;
-use rome_json_parser::parse_json;
+use rome_json_parser::{parse_json, JsonParserOptions};
+use serde::{Deserialize, Serialize};
+use std::fmt::Debug;
+use std::io::ErrorKind;
+use std::num::NonZeroU64;
+use std::path::{Path, PathBuf};
 
 /// The configuration that is contained inside the file `rome.json`
 #[derive(Debug, Deserialize, Serialize, Clone, Bpaf)]
@@ -81,6 +81,11 @@ pub struct Configuration {
     #[bpaf(external(javascript_configuration), optional)]
     pub javascript: Option<JavascriptConfiguration>,
 
+    /// Specific configuration for the Json language
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[bpaf(external(json_configuration), optional)]
+    pub json: Option<JsonConfiguration>,
+
     /// A list of paths to other JSON files, used to extends the current configuration.
     #[serde(skip_serializing_if = "Option::is_none")]
     #[bpaf(hide)]
@@ -101,6 +106,7 @@ impl Default for Configuration {
             schema: None,
             vcs: None,
             extends: None,
+            json: None,
         }
     }
 }
@@ -112,6 +118,7 @@ impl Configuration {
         "linter",
         "formatter",
         "javascript",
+        "json",
         "$schema",
         "organizeImports",
         "extends",
@@ -395,7 +402,7 @@ pub fn create_config(
         WorkspaceError::Configuration(ConfigurationDiagnostic::new_serialization_error())
     })?;
 
-    let parsed = parse_json(&contents);
+    let parsed = parse_json(&contents, JsonParserOptions::default());
     let formatted =
         rome_json_formatter::format_node(JsonFormatOptions::default(), &parsed.syntax())?
             .print()
diff --git a/crates/rome_service/src/configuration/parse/json/configuration.rs b/crates/rome_service/src/configuration/parse/json/configuration.rs
index 12a441a2e8e..2fdb637d62d 100644
--- a/crates/rome_service/src/configuration/parse/json/configuration.rs
+++ b/crates/rome_service/src/configuration/parse/json/configuration.rs
@@ -1,3 +1,4 @@
+use crate::configuration::json::JsonConfiguration;
 use crate::configuration::organize_imports::OrganizeImports;
 use crate::configuration::parse::json::vcs::validate_vcs_configuration;
 use crate::configuration::vcs::VcsConfiguration;
@@ -60,6 +61,11 @@ impl VisitNode<JsonLanguage> for Configuration {
                 self.map_to_object(&value, name_text, &mut javascript, diagnostics)?;
                 self.javascript = Some(javascript);
             }
+            "json" => {
+                let mut json = JsonConfiguration::default();
+                self.map_to_object(&value, name_text, &mut json, diagnostics)?;
+                self.json = Some(json);
+            }
             "organizeImports" => {
                 let mut organize_imports = OrganizeImports::default();
                 self.map_to_object(&value, name_text, &mut organize_imports, diagnostics)?;
diff --git a/crates/rome_service/src/configuration/parse/json/javascript.rs b/crates/rome_service/src/configuration/parse/json/javascript.rs
index d01254bac65..4ebceddce4f 100644
--- a/crates/rome_service/src/configuration/parse/json/javascript.rs
+++ b/crates/rome_service/src/configuration/parse/json/javascript.rs
@@ -34,6 +34,13 @@ impl VisitNode<JsonLanguage> for JavascriptConfiguration {
                 self.map_to_object(&value, name_text, &mut javascript_formatter, diagnostics)?;
                 self.formatter = Some(javascript_formatter);
             }
+
+            "parser" => {
+                let mut parser = JavascriptParser::default();
+                self.map_to_object(&value, name_text, &mut parser, diagnostics)?;
+                self.parser = Some(parser);
+            }
+
             "globals" => {
                 self.globals = self
                     .map_to_index_set_string(&value, name_text, diagnostics)
diff --git a/crates/rome_service/src/configuration/parse/json/json_configuration.rs b/crates/rome_service/src/configuration/parse/json/json_configuration.rs
new file mode 100644
index 00000000000..4b1901a4666
--- /dev/null
+++ b/crates/rome_service/src/configuration/parse/json/json_configuration.rs
@@ -0,0 +1,62 @@
+use crate::configuration::json::{JsonConfiguration, JsonParser};
+
+use rome_deserialize::json::{has_only_known_keys, VisitJsonNode};
+use rome_deserialize::{DeserializationDiagnostic, VisitNode};
+use rome_json_syntax::{JsonLanguage, JsonSyntaxNode};
+use rome_rowan::SyntaxNode;
+
+impl VisitJsonNode for JsonConfiguration {}
+
+impl VisitNode<JsonLanguage> for JsonConfiguration {
+    fn visit_member_name(
+        &mut self,
+        node: &JsonSyntaxNode,
+        diagnostics: &mut Vec<DeserializationDiagnostic>,
+    ) -> Option<()> {
+        has_only_known_keys(node, JsonConfiguration::KNOWN_KEYS, diagnostics)
+    }
+
+    fn visit_map(
+        &mut self,
+        key: &SyntaxNode<JsonLanguage>,
+        value: &SyntaxNode<JsonLanguage>,
+        diagnostics: &mut Vec<DeserializationDiagnostic>,
+    ) -> Option<()> {
+        let (name, value) = self.get_key_and_value(key, value, diagnostics)?;
+        let name_text = name.text();
+
+        if let "parser" = name_text {
+            let mut parser = JsonParser::default();
+            self.map_to_object(&value, name_text, &mut parser, diagnostics)?;
+            self.parser = Some(parser);
+        }
+
+        Some(())
+    }
+}
+
+impl VisitJsonNode for JsonParser {}
+impl VisitNode<JsonLanguage> for JsonParser {
+    fn visit_member_name(
+        &mut self,
+        node: &JsonSyntaxNode,
+        diagnostics: &mut Vec<DeserializationDiagnostic>,
+    ) -> Option<()> {
+        has_only_known_keys(node, JsonParser::KNOWN_KEYS, diagnostics)
+    }
+
+    fn visit_map(
+        &mut self,
+        key: &SyntaxNode<JsonLanguage>,
+        value: &SyntaxNode<JsonLanguage>,
+        diagnostics: &mut Vec<DeserializationDiagnostic>,
+    ) -> Option<()> {
+        let (name, value) = self.get_key_and_value(key, value, diagnostics)?;
+        let name_text = name.text();
+        if name_text == "allowComments" {
+            self.allow_comments = self.map_to_boolean(&value, name_text, diagnostics);
+        }
+
+        Some(())
+    }
+}
diff --git a/crates/rome_service/src/configuration/parse/json.rs b/crates/rome_service/src/configuration/parse/json/mod.rs
similarity index 98%
rename from crates/rome_service/src/configuration/parse/json.rs
rename to crates/rome_service/src/configuration/parse/json/mod.rs
index 0a1844d52be..74e37e25eff 100644
--- a/crates/rome_service/src/configuration/parse/json.rs
+++ b/crates/rome_service/src/configuration/parse/json/mod.rs
@@ -5,6 +5,7 @@ mod configuration;
 mod files;
 mod formatter;
 mod javascript;
+mod json_configuration;
 mod linter;
 mod organize_imports;
 mod rules;
diff --git a/crates/rome_service/src/configuration/string_set.rs b/crates/rome_service/src/configuration/string_set.rs
index 1b09ad073f5..dbd5fd93138 100644
--- a/crates/rome_service/src/configuration/string_set.rs
+++ b/crates/rome_service/src/configuration/string_set.rs
@@ -104,3 +104,9 @@ impl FromStr for StringSet {
         Ok(StringSet::default())
     }
 }
+
+impl From<IndexSet<String>> for StringSet {
+    fn from(value: IndexSet<String>) -> Self {
+        Self::new(value)
+    }
+}
diff --git a/crates/rome_service/src/file_handlers/javascript.rs b/crates/rome_service/src/file_handlers/javascript.rs
index f4ec23981e3..dd9840a6611 100644
--- a/crates/rome_service/src/file_handlers/javascript.rs
+++ b/crates/rome_service/src/file_handlers/javascript.rs
@@ -59,6 +59,12 @@ pub struct JsParserSettings {
     pub parse_class_parameter_decorators: bool,
 }
 
+#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+pub struct JsonParserSettings {
+    pub allow_comments: bool,
+}
+
 #[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct JsLinterSettings {
@@ -248,12 +254,12 @@ fn lint(params: LintParams) -> LintResults {
     let Ok(file_source) = params
         .parse
         .file_source(params.path) else {
-		return LintResults {
-			errors: 0,
-			diagnostics: vec![],
-			skipped_diagnostics: 0
-		}
-	};
+        return LintResults {
+            errors: 0,
+            diagnostics: vec![],
+            skipped_diagnostics: 0
+        }
+    };
     let tree = params.parse.tree();
     let mut diagnostics = params.parse.into_diagnostics();
 
@@ -403,10 +409,10 @@ fn code_actions(
     trace!("Filter applied for code actions: {:?}", &filter);
     let analyzer_options = compute_analyzer_options(&settings, PathBuf::from(path.as_path()));
     let Ok(source_type) = parse.file_source(path) else {
-		return PullActionsResult {
-			actions: vec![]
-		}
-	};
+        return PullActionsResult {
+            actions: vec![]
+        }
+    };
 
     analyze(&tree, filter, &analyzer_options, source_type, |signal| {
         actions.extend(signal.actions().into_code_action_iter().map(|item| {
diff --git a/crates/rome_service/src/file_handlers/json.rs b/crates/rome_service/src/file_handlers/json.rs
index 222c195bb4e..bae1ee5cd02 100644
--- a/crates/rome_service/src/file_handlers/json.rs
+++ b/crates/rome_service/src/file_handlers/json.rs
@@ -1,5 +1,6 @@
 use super::{ExtensionHandler, Mime};
 use crate::configuration::to_analyzer_configuration;
+use crate::file_handlers::javascript::JsonParserSettings;
 use crate::file_handlers::{
     AnalyzerCapabilities, Capabilities, FixAllParams, FormatterCapabilities, LintParams,
     LintResults, ParserCapabilities,
@@ -20,6 +21,7 @@ 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_parser::JsonParserOptions;
 use rome_json_syntax::{JsonFileSource, JsonLanguage, JsonRoot, JsonSyntaxNode};
 use rome_parser::AnyParse;
 use rome_rowan::{AstNode, FileSource, NodeCache};
@@ -29,10 +31,9 @@ use std::path::PathBuf;
 impl Language for JsonLanguage {
     type FormatterSettings = ();
     type LinterSettings = ();
-    type FormatOptions = JsonFormatOptions;
     type OrganizeImportsSettings = ();
-    type ParserSettings = ();
-
+    type FormatOptions = JsonFormatOptions;
+    type ParserSettings = JsonParserSettings;
     fn lookup_settings(language: &LanguagesSettings) -> &LanguageSettings<Self> {
         &language.json
     }
@@ -89,21 +90,31 @@ impl ExtensionHandler for JsonFileHandler {
 }
 
 fn parse(
-    _: &RomePath,
-    _: LanguageId,
+    rome_path: &RomePath,
+    language_hint: LanguageId,
     text: &str,
-    _: SettingsHandle,
+    settings: SettingsHandle,
     cache: &mut NodeCache,
 ) -> AnyParse {
-    let parse = rome_json_parser::parse_json_with_cache(text, cache);
+    let _parser = &settings.as_ref().languages.json.parser;
+    let options: JsonParserOptions = JsonParserOptions {
+        // TODO: enable once the formatter is ready
+        allow_comments: false,
+    };
+    let source_type =
+        JsonFileSource::try_from(rome_path.as_path()).unwrap_or_else(|_| match language_hint {
+            LanguageId::Json => JsonFileSource::json(),
+            LanguageId::Jsonc => JsonFileSource::jsonc(),
+            _ => JsonFileSource::json(),
+        });
+    let parse = rome_json_parser::parse_json_with_cache(text, cache, options);
     let root = parse.syntax();
     let diagnostics = parse.into_diagnostics();
-
     AnyParse::new(
         // SAFETY: the parser should always return a root node
         root.as_send().unwrap(),
         diagnostics,
-        JsonFileSource::json().as_any_file_source(),
+        source_type.as_any_file_source(),
     )
 }
 
@@ -149,7 +160,6 @@ fn format(
     }
 }
 
-#[tracing::instrument(level = "debug", skip(parse))]
 fn format_range(
     rome_path: &RomePath,
     parse: AnyParse,
@@ -163,7 +173,6 @@ fn format_range(
     Ok(printed)
 }
 
-#[tracing::instrument(level = "debug", skip(parse))]
 fn format_on_type(
     rome_path: &RomePath,
     parse: AnyParse,
@@ -199,7 +208,6 @@ fn format_on_type(
     let printed = rome_json_formatter::format_sub_tree(options, &root_node)?;
     Ok(printed)
 }
-
 fn lint(params: LintParams) -> LintResults {
     tracing::debug_span!("lint").in_scope(move || {
         let root: JsonRoot = params.parse.tree();
@@ -292,7 +300,6 @@ fn lint(params: LintParams) -> LintResults {
         }
     })
 }
-
 fn code_actions(
     _parse: AnyParse,
     _range: TextRange,
diff --git a/crates/rome_service/src/file_handlers/mod.rs b/crates/rome_service/src/file_handlers/mod.rs
index 354e483794b..a2002c1e181 100644
--- a/crates/rome_service/src/file_handlers/mod.rs
+++ b/crates/rome_service/src/file_handlers/mod.rs
@@ -36,6 +36,8 @@ pub enum Language {
     TypeScriptReact,
     /// JSON
     Json,
+    /// JSONC
+    Jsonc,
     /// Any language that is not supported
     #[default]
     Unknown,
@@ -118,6 +120,7 @@ impl rome_console::fmt::Display for Language {
             Language::TypeScript => fmt.write_markup(markup! { "TypeScript" }),
             Language::TypeScriptReact => fmt.write_markup(markup! { "TSX" }),
             Language::Json => fmt.write_markup(markup! { "JSON" }),
+            Language::Jsonc => fmt.write_markup(markup! { "JSONC" }),
             Language::Unknown => fmt.write_markup(markup! { "Unknown" }),
         }
     }
@@ -305,7 +308,7 @@ impl Features {
             | Language::JavaScriptReact
             | Language::TypeScript
             | Language::TypeScriptReact => self.js.capabilities(),
-            Language::Json => self.json.capabilities(),
+            Language::Json | Language::Jsonc => self.json.capabilities(),
             Language::Unknown => self.unknown.capabilities(),
         }
     }
diff --git a/crates/rome_service/src/settings.rs b/crates/rome_service/src/settings.rs
index 500fcfed82b..5ab6e74f6f5 100644
--- a/crates/rome_service/src/settings.rs
+++ b/crates/rome_service/src/settings.rs
@@ -96,6 +96,15 @@ impl WorkspaceSettings {
             if let Some(_organize_imports) = organize_imports {}
         }
 
+        // json settings
+        let json = configuration.json;
+        if let Some(json) = json {
+            if let Some(parser) = json.parser {
+                self.languages.json.parser.allow_comments =
+                    parser.allow_comments.unwrap_or_default();
+            }
+        }
+
         Ok(())
     }
 
diff --git a/crates/rome_service/tests/invalid/top_level_extraneous_field.json.snap b/crates/rome_service/tests/invalid/top_level_extraneous_field.json.snap
index b606b3348d8..3af1db146d6 100644
--- a/crates/rome_service/tests/invalid/top_level_extraneous_field.json.snap
+++ b/crates/rome_service/tests/invalid/top_level_extraneous_field.json.snap
@@ -19,6 +19,7 @@ top_level_extraneous_field.json:2:2 deserialize ━━━━━━━━━━
   - linter
   - formatter
   - javascript
+  - json
   - $schema
   - organizeImports
   - extends
diff --git a/editors/vscode/configuration_schema.json b/editors/vscode/configuration_schema.json
index d0ea9053ee5..f90a2928d00 100644
--- a/editors/vscode/configuration_schema.json
+++ b/editors/vscode/configuration_schema.json
@@ -33,6 +33,13 @@
 				{ "type": "null" }
 			]
 		},
+		"json": {
+			"description": "Specific configuration for the Json language",
+			"anyOf": [
+				{ "$ref": "#/definitions/JsonConfiguration" },
+				{ "type": "null" }
+			]
+		},
 		"linter": {
 			"description": "The configuration for the linter",
 			"anyOf": [
@@ -713,6 +720,25 @@
 			},
 			"additionalProperties": false
 		},
+		"JsonConfiguration": {
+			"type": "object",
+			"properties": {
+				"parser": {
+					"anyOf": [{ "$ref": "#/definitions/JsonParser" }, { "type": "null" }]
+				}
+			},
+			"additionalProperties": false
+		},
+		"JsonParser": {
+			"type": "object",
+			"properties": {
+				"allowComments": {
+					"description": "Allow parsing comments in `.json` files",
+					"type": ["boolean", "null"]
+				}
+			},
+			"additionalProperties": false
+		},
 		"LineWidth": {
 			"description": "Validated value for the `line_width` formatter options\n\nThe allowed range of values is 1..=320",
 			"type": "integer",
diff --git a/npm/backend-jsonrpc/src/workspace.ts b/npm/backend-jsonrpc/src/workspace.ts
index 40036170998..b637ccdf70e 100644
--- a/npm/backend-jsonrpc/src/workspace.ts
+++ b/npm/backend-jsonrpc/src/workspace.ts
@@ -43,6 +43,10 @@ export interface Configuration {
 	 * Specific configuration for the JavaScript language
 	 */
 	javascript?: JavascriptConfiguration;
+	/**
+	 * Specific configuration for the Json language
+	 */
+	json?: JsonConfiguration;
 	/**
 	 * The configuration for the linter
 	 */
@@ -111,6 +115,9 @@ If defined here, they should not emit diagnostics.
 	organize_imports?: JavascriptOrganizeImports;
 	parser?: JavascriptParser;
 }
+export interface JsonConfiguration {
+	parser?: JsonParser;
+}
 export interface LinterConfiguration {
 	/**
 	 * if `false`, it disables the feature and the linter won't be executed. `true` by default
@@ -200,6 +207,12 @@ These decorators belong to an old proposal, and they are subject to change.
 	 */
 	unsafeParameterDecoratorsEnabled?: boolean;
 }
+export interface JsonParser {
+	/**
+	 * Allow parsing comments in `.json` files
+	 */
+	allowComments?: boolean;
+}
 export interface Rules {
 	a11y?: A11y;
 	/**
@@ -1020,6 +1033,7 @@ export type Language =
 	| "TypeScript"
 	| "TypeScriptReact"
 	| "Json"
+	| "Jsonc"
 	| "Unknown";
 export interface ChangeFileParams {
 	content: string;
diff --git a/npm/rome/configuration_schema.json b/npm/rome/configuration_schema.json
index d0ea9053ee5..f90a2928d00 100644
--- a/npm/rome/configuration_schema.json
+++ b/npm/rome/configuration_schema.json
@@ -33,6 +33,13 @@
 				{ "type": "null" }
 			]
 		},
+		"json": {
+			"description": "Specific configuration for the Json language",
+			"anyOf": [
+				{ "$ref": "#/definitions/JsonConfiguration" },
+				{ "type": "null" }
+			]
+		},
 		"linter": {
 			"description": "The configuration for the linter",
 			"anyOf": [
@@ -713,6 +720,25 @@
 			},
 			"additionalProperties": false
 		},
+		"JsonConfiguration": {
+			"type": "object",
+			"properties": {
+				"parser": {
+					"anyOf": [{ "$ref": "#/definitions/JsonParser" }, { "type": "null" }]
+				}
+			},
+			"additionalProperties": false
+		},
+		"JsonParser": {
+			"type": "object",
+			"properties": {
+				"allowComments": {
+					"description": "Allow parsing comments in `.json` files",
+					"type": ["boolean", "null"]
+				}
+			},
+			"additionalProperties": false
+		},
 		"LineWidth": {
 			"description": "Validated value for the `line_width` formatter options\n\nThe allowed range of values is 1..=320",
 			"type": "integer",
diff --git a/xtask/bench/src/language.rs b/xtask/bench/src/language.rs
index 124d90bc350..5fa9c2def7d 100644
--- a/xtask/bench/src/language.rs
+++ b/xtask/bench/src/language.rs
@@ -7,6 +7,7 @@ use rome_js_formatter::context::{JsFormatContext, JsFormatOptions};
 use rome_js_parser::JsParserOptions;
 use rome_js_syntax::{AnyJsRoot, JsFileSource, JsSyntaxNode};
 use rome_json_formatter::context::{JsonFormatContext, JsonFormatOptions};
+use rome_json_parser::JsonParserOptions;
 use rome_json_syntax::JsonSyntaxNode;
 use rome_parser::prelude::ParseDiagnostic;
 use rome_rowan::NodeCache;
@@ -30,14 +31,13 @@ impl<'a> Parse<'a> {
     pub fn parse(&self) -> Parsed {
         match self {
             Parse::JavaScript(source_type, code) => Parsed::JavaScript(
-                rome_js_parser::parse(
-                    code,
-                    *source_type,
-                    JsParserOptions::default().with_parse_class_parameter_decorators(),
-                ),
+                rome_js_parser::parse(code, *source_type, JsParserOptions::default()),
                 *source_type,
             ),
-            Parse::Json(code) => Parsed::Json(rome_json_parser::parse_json(code)),
+            Parse::Json(code) => Parsed::Json(rome_json_parser::parse_json(
+                code,
+                JsonParserOptions::default(),
+            )),
         }
     }
 
@@ -47,12 +47,16 @@ impl<'a> Parse<'a> {
                 rome_js_parser::parse_js_with_cache(
                     code,
                     *source_type,
-                    JsParserOptions::default().with_parse_class_parameter_decorators(),
+                    JsParserOptions::default(),
                     cache,
                 ),
                 *source_type,
             ),
-            Parse::Json(code) => Parsed::Json(rome_json_parser::parse_json_with_cache(code, cache)),
+            Parse::Json(code) => Parsed::Json(rome_json_parser::parse_json_with_cache(
+                code,
+                cache,
+                JsonParserOptions::default(),
+            )),
         }
     }
 }
diff --git a/xtask/codegen/src/generate_schema.rs b/xtask/codegen/src/generate_schema.rs
index 79e4e9fdceb..a99fc43f99e 100644
--- a/xtask/codegen/src/generate_schema.rs
+++ b/xtask/codegen/src/generate_schema.rs
@@ -1,5 +1,5 @@
 use rome_json_formatter::context::JsonFormatOptions;
-use rome_json_parser::parse_json;
+use rome_json_parser::{parse_json, JsonParserOptions};
 use rome_service::Configuration;
 use schemars::schema_for;
 use serde_json::to_string;
@@ -13,7 +13,7 @@ pub(crate) fn generate_configuration_schema(mode: Mode) -> Result<()> {
     let schema = schema_for!(Configuration);
     let json_schema = to_string(&schema)?;
 
-    let parsed = parse_json(&json_schema);
+    let parsed = parse_json(&json_schema, JsonParserOptions::default());
     let formatted =
         rome_json_formatter::format_node(JsonFormatOptions::default(), &parsed.syntax())
             .unwrap()
diff --git a/xtask/lintdoc/src/main.rs b/xtask/lintdoc/src/main.rs
index e443198c556..39f9587d998 100644
--- a/xtask/lintdoc/src/main.rs
+++ b/xtask/lintdoc/src/main.rs
@@ -12,6 +12,7 @@ use rome_diagnostics::termcolor::NoColor;
 use rome_diagnostics::{Diagnostic, DiagnosticExt, PrintDiagnostic};
 use rome_js_parser::JsParserOptions;
 use rome_js_syntax::{JsFileSource, JsLanguage, Language, LanguageVariant, ModuleKind};
+use rome_json_parser::JsonParserOptions;
 use rome_json_syntax::JsonLanguage;
 use rome_service::settings::WorkspaceSettings;
 use std::{
@@ -605,8 +606,8 @@ fn assert_lint(
                         if let Some(mut diag) = signal.diagnostic() {
                             let category = diag.category().expect("linter diagnostic has no code");
                             let severity = settings.get_severity_from_rule_code(category).expect(
-                            "If you see this error, it means you need to run cargo codegen-configuration",
-                        );
+                                "If you see this error, it means you need to run cargo codegen-configuration",
+                            );
 
                             for action in signal.actions() {
                                 if !action.is_suppression() {
@@ -646,7 +647,7 @@ fn assert_lint(
             }
         }
         BlockType::Json => {
-            let parse = rome_json_parser::parse_json(code);
+            let parse = rome_json_parser::parse_json(code, JsonParserOptions::default());
 
             if parse.has_errors() {
                 for diag in parse.into_diagnostics() {
@@ -675,8 +676,8 @@ fn assert_lint(
                         if let Some(mut diag) = signal.diagnostic() {
                             let category = diag.category().expect("linter diagnostic has no code");
                             let severity = settings.get_severity_from_rule_code(category).expect(
-								"If you see this error, it means you need to run cargo codegen-configuration",
-							);
+                                "If you see this error, it means you need to run cargo codegen-configuration",
+                            );
 
                             for action in signal.actions() {
                                 if !action.is_suppression() {