diff --git a/CHANGELOG.md b/CHANGELOG.md
index 502b3f8d2c23..116a3648e1d7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,11 +14,26 @@ Read our [guidelines for writing a good changelog entry](https://github.com/biom
 
 ### CLI
 
+### Bug fixes
+
 - Fix [#1512](https://github.com/biomejs/biome/issues/1512) by skipping verbose diagnostics from the count. Contributed by @ematipico
-- Don't handle CSS files, the formatter isn't ready yet. Contributed by @ematipico
+
+- Don't emit verbose warnings when a protected file is ignored.
+
+  Some files, such as `package.json` and `tsconfig.json`, are [protected](https://biomejs.dev/guides/how-biome-works/#protected-files).
+  Biome emits a verbose warning when it encounters a protected file.
+
+  Previously, Biome emitted this verbose warning even if the file was ignored by the configuration.
+  Now, it doesn't emit verbose warnings for protected files that are ignored.
+
+  Contributed by @Conaclos
+
 - The file `biome.json` can't be ignored anymore. Contributed by @ematipico
+
 - Fix [#1541](https://github.com/biomejs/biome/issues/1541) where the content of protected files wasn't returned to `stdout`. Contributed by @ematipico
 
+- Don't handle CSS files, the formatter isn't ready yet. Contributed by @ematipico
+
 ### Configuration
 
 #### Bug fixes
diff --git a/crates/biome_cli/tests/cases/protected_files.rs b/crates/biome_cli/tests/cases/protected_files.rs
index 01bebf9dc4dd..6e39754a0cda 100644
--- a/crates/biome_cli/tests/cases/protected_files.rs
+++ b/crates/biome_cli/tests/cases/protected_files.rs
@@ -126,6 +126,7 @@ fn not_process_file_from_cli() {
         result,
     ));
 }
+
 #[test]
 fn not_process_file_from_cli_verbose() {
     let mut fs = MemoryFileSystem::default();
@@ -158,6 +159,88 @@ fn not_process_file_from_cli_verbose() {
     ));
 }
 
+#[test]
+fn not_process_ignored_file_from_cli_verbose() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let file_path = Path::new("package.json");
+    fs.insert(file_path.into(), r#"{ "name": "test" }"#.as_bytes());
+
+    let file_path = Path::new("other.json");
+    fs.insert(file_path.into(), r#"{}"#.as_bytes());
+
+    let file_path1 = Path::new("biome.json");
+    fs.insert(
+        file_path1.into(),
+        r#"{ "files": { "ignore": ["package.json"] } }"#.as_bytes(),
+    );
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from(
+            [
+                ("format"),
+                "--verbose",
+                file_path.as_os_str().to_str().unwrap(),
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "not_process_ignored_file_from_cli_verbose",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn not_process_file_linter_disabled_from_cli_verbose() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let file_path = Path::new("package.json");
+    fs.insert(file_path.into(), r#"{ "name": "test" }"#.as_bytes());
+
+    let file_path = Path::new("other.json");
+    fs.insert(file_path.into(), r#"{}"#.as_bytes());
+
+    let file_path1 = Path::new("biome.json");
+    fs.insert(
+        file_path1.into(),
+        r#"{ "linter": { "enabled": false } }"#.as_bytes(),
+    );
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from(
+            [
+                ("format"),
+                "--verbose",
+                file_path.as_os_str().to_str().unwrap(),
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "not_process_file_linter_disabled_from_cli_verbose",
+        fs,
+        console,
+        result,
+    ));
+}
+
 #[test]
 fn should_return_the_content_of_protected_files_via_stdin() {
     let mut fs = MemoryFileSystem::default();
diff --git a/crates/biome_cli/tests/snapshots/main_cases_protected_files/not_process_file_linter_disabled_from_cli_verbose.snap b/crates/biome_cli/tests/snapshots/main_cases_protected_files/not_process_file_linter_disabled_from_cli_verbose.snap
new file mode 100644
index 000000000000..8f0230b4c34a
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_protected_files/not_process_file_linter_disabled_from_cli_verbose.snap
@@ -0,0 +1,52 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: content
+---
+## `biome.json`
+
+```json
+{ "linter": { "enabled": false } }
+```
+
+## `other.json`
+
+```json
+{}
+```
+
+## `package.json`
+
+```json
+{ "name": "test" }
+```
+
+# Termination Message
+
+```block
+format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+other.json format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Formatter would have printed the following content:
+  
+    1   │ - {}
+      1 │ + {}
+      2 │ + 
+  
+
+```
+
+```block
+Compared 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/biome_cli/tests/snapshots/main_cases_protected_files/not_process_ignored_file_from_cli_verbose.snap b/crates/biome_cli/tests/snapshots/main_cases_protected_files/not_process_ignored_file_from_cli_verbose.snap
new file mode 100644
index 000000000000..e526ff60abb5
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_protected_files/not_process_ignored_file_from_cli_verbose.snap
@@ -0,0 +1,52 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: content
+---
+## `biome.json`
+
+```json
+{ "files": { "ignore": ["package.json"] } }
+```
+
+## `other.json`
+
+```json
+{}
+```
+
+## `package.json`
+
+```json
+{ "name": "test" }
+```
+
+# Termination Message
+
+```block
+format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+other.json format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Formatter would have printed the following content:
+  
+    1   │ - {}
+      1 │ + {}
+      2 │ + 
+  
+
+```
+
+```block
+Compared 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/biome_service/src/workspace.rs b/crates/biome_service/src/workspace.rs
index f0695b327314..f0c0b753d765 100644
--- a/crates/biome_service/src/workspace.rs
+++ b/crates/biome_service/src/workspace.rs
@@ -95,29 +95,38 @@ pub struct FileFeaturesResult {
 }
 
 impl FileFeaturesResult {
-    /// Files that should not be processed no matter the cases
-    pub(crate) const FILES_TO_NOT_PROCESS: &'static [&'static str; 12] = &[
-        "package.json",
-        "package-lock.json",
-        "npm-shrinkwrap.json",
-        "yarn.lock",
+    /// Sorted array of files that should not be processed no matter the cases.
+    /// These files are handled by other tools.
+    const PROTECTED_FILES: &'static [&'static str; 11] = &[
+        // Composer
         "composer.json",
         "composer.lock",
-        "typescript.json",
-        "tsconfig.json",
-        "jsconfig.json",
+        // Deno
         "deno.json",
         "deno.jsonc",
-        // TODO: remove this when are able to handle nested .gitignore files
-        ".gitignore",
+        // TSC
+        "jsconfig.json",
+        // NPM
+        "npm-shrinkwrap.json",
+        "package-lock.json",
+        "package.json",
+        // TSC
+        "tsconfig.json",
+        "typescript.json",
+        // Yarn
+        "yarn.lock",
     ];
 
-    /// Checks whether this file can be processed
-    fn can_process(&self, path: &Path) -> bool {
+    /// Checks whether this file is protected.
+    /// A protected file is handled by a specific tool and should be ignored.
+    pub(crate) fn is_protected_file(path: &Path) -> bool {
         path.file_name()
             .and_then(OsStr::to_str)
-            .map(|file_name| !FileFeaturesResult::FILES_TO_NOT_PROCESS.contains(&file_name))
-            .unwrap_or_default()
+            .is_some_and(|file_name| {
+                FileFeaturesResult::PROTECTED_FILES
+                    .binary_search(&file_name)
+                    .is_ok()
+            })
     }
 
     /// By default, all features are not supported by a file.
@@ -156,48 +165,44 @@ impl FileFeaturesResult {
         language: &Language,
         path: &Path,
     ) -> Self {
-        if self.can_process(path) {
-            let formatter_disabled =
-                if let Some(disabled) = settings.override_settings.formatter_disabled(path) {
-                    disabled
-                } else if language.is_javascript_like() {
-                    !settings.formatter().enabled || settings.javascript_formatter_disabled()
-                } else if language.is_json_like() {
-                    !settings.formatter().enabled || settings.json_formatter_disabled()
-                } else if language.is_css_like() {
-                    !can_format_css_yet()
-                        || !settings.formatter().enabled
-                        || settings.css_formatter_disabled()
-                } else {
-                    !settings.formatter().enabled
-                };
-            if formatter_disabled {
-                self.features_supported
-                    .insert(FeatureName::Format, SupportKind::FeatureNotEnabled);
-            }
-            // linter
-            if let Some(disabled) = settings.override_settings.linter_disabled(path) {
-                if disabled {
-                    self.features_supported
-                        .insert(FeatureName::Lint, SupportKind::FeatureNotEnabled);
-                }
-            } else if !settings.linter().enabled {
+        let formatter_disabled =
+            if let Some(disabled) = settings.override_settings.formatter_disabled(path) {
+                disabled
+            } else if language.is_javascript_like() {
+                !settings.formatter().enabled || settings.javascript_formatter_disabled()
+            } else if language.is_json_like() {
+                !settings.formatter().enabled || settings.json_formatter_disabled()
+            } else if language.is_css_like() {
+                !can_format_css_yet()
+                    || !settings.formatter().enabled
+                    || settings.css_formatter_disabled()
+            } else {
+                !settings.formatter().enabled
+            };
+        if formatter_disabled {
+            self.features_supported
+                .insert(FeatureName::Format, SupportKind::FeatureNotEnabled);
+        }
+        // linter
+        if let Some(disabled) = settings.override_settings.linter_disabled(path) {
+            if disabled {
                 self.features_supported
                     .insert(FeatureName::Lint, SupportKind::FeatureNotEnabled);
             }
+        } else if !settings.linter().enabled {
+            self.features_supported
+                .insert(FeatureName::Lint, SupportKind::FeatureNotEnabled);
+        }
 
-            // organize imports
-            if let Some(disabled) = settings.override_settings.organize_imports_disabled(path) {
-                if disabled {
-                    self.features_supported
-                        .insert(FeatureName::OrganizeImports, SupportKind::FeatureNotEnabled);
-                }
-            } else if !settings.organize_imports().enabled {
+        // organize imports
+        if let Some(disabled) = settings.override_settings.organize_imports_disabled(path) {
+            if disabled {
                 self.features_supported
                     .insert(FeatureName::OrganizeImports, SupportKind::FeatureNotEnabled);
             }
-        } else {
-            self.features_supported = HashMap::from(FileFeaturesResult::WORKSPACE_FEATURES);
+        } else if !settings.organize_imports().enabled {
+            self.features_supported
+                .insert(FeatureName::OrganizeImports, SupportKind::FeatureNotEnabled);
         }
 
         debug!(
@@ -283,6 +288,20 @@ impl FileFeaturesResult {
             .values()
             .all(|support_kind| support_kind.is_not_enabled())
     }
+
+    /// The file is not processed if for every enabled feature
+    /// the file is either protected, not supported, ignored.
+    pub fn is_not_processed(&self) -> bool {
+        self.features_supported.values().all(|support_kind| {
+            matches!(
+                support_kind,
+                SupportKind::FeatureNotEnabled
+                    | SupportKind::FileNotSupported
+                    | SupportKind::Ignored
+                    | SupportKind::Protected
+            )
+        })
+    }
 }
 
 impl SupportsFeatureResult {
@@ -859,3 +878,10 @@ impl<'app, W: Workspace + ?Sized> Drop for FileGuard<'app, W> {
             .ok();
     }
 }
+
+#[test]
+fn test_order() {
+    for items in FileFeaturesResult::PROTECTED_FILES.windows(2) {
+        assert!(items[0] < items[1], "{} < {}", items[0], items[1]);
+    }
+}
diff --git a/crates/biome_service/src/workspace/server.rs b/crates/biome_service/src/workspace/server.rs
index 8c4dff110cd0..b144707e2c7d 100644
--- a/crates/biome_service/src/workspace/server.rs
+++ b/crates/biome_service/src/workspace/server.rs
@@ -226,39 +226,37 @@ impl Workspace for WorkspaceServer {
             Entry::Vacant(entry) => {
                 let capabilities = self.get_file_capabilities(&params.path);
                 let language = Language::from_path(&params.path);
-                let file_name = params
-                    .path
-                    .file_name()
-                    .and_then(|file_name| file_name.to_str());
+                let path = params.path.as_path();
                 let settings = self.settings.read().unwrap();
                 let mut file_features = FileFeaturesResult::new();
 
-                if let Some(file_name) = file_name {
-                    if FileFeaturesResult::FILES_TO_NOT_PROCESS.contains(&file_name) {
-                        file_features.set_protected_for_all_features();
-                        return Ok(entry.insert(file_features).clone());
-                    }
-                }
-
                 file_features = file_features
                     .with_capabilities(&capabilities)
-                    .with_settings_and_language(&settings, &language, params.path.as_path());
-
-                if settings.files.ignore_unknown {
-                    let language = self.get_language(&params.path);
-                    if language == Language::Unknown {
-                        file_features.ignore_not_supported();
+                    .with_settings_and_language(&settings, &language, path);
+
+                if settings.files.ignore_unknown
+                    && language == Language::Unknown
+                    && self.get_language(&params.path) == Language::Unknown
+                {
+                    file_features.ignore_not_supported();
+                } else {
+                    for feature in params.feature {
+                        let is_ignored = self.is_path_ignored(IsPathIgnoredParams {
+                            rome_path: params.path.clone(),
+                            feature: feature.clone(),
+                        })?;
+                        if is_ignored {
+                            file_features.ignored(feature);
+                        }
                     }
                 }
-                for feature in params.feature {
-                    let is_ignored = self.is_path_ignored(IsPathIgnoredParams {
-                        rome_path: params.path.clone(),
-                        feature: feature.clone(),
-                    })?;
-
-                    if is_ignored {
-                        file_features.ignored(feature);
-                    }
+
+                // If the file is not ignored by at least one feature,
+                // then check that the file is not protected.
+                // Protected files must be ignored.
+                if !file_features.is_not_processed() && FileFeaturesResult::is_protected_file(path)
+                {
+                    file_features.set_protected_for_all_features();
                 }
 
                 Ok(entry.insert(file_features).clone())
diff --git a/website/src/content/docs/internals/changelog.mdx b/website/src/content/docs/internals/changelog.mdx
index 8897521b3370..d60104d50a35 100644
--- a/website/src/content/docs/internals/changelog.mdx
+++ b/website/src/content/docs/internals/changelog.mdx
@@ -20,11 +20,26 @@ Read our [guidelines for writing a good changelog entry](https://github.com/biom
 
 ### CLI
 
+### Bug fixes
+
 - Fix [#1512](https://github.com/biomejs/biome/issues/1512) by skipping verbose diagnostics from the count. Contributed by @ematipico
-- Don't handle CSS files, the formatter isn't ready yet. Contributed by @ematipico
+
+- Don't emit verbose warnings when a protected file is ignored.
+
+  Some files, such as `package.json` and `tsconfig.json`, are [protected](https://biomejs.dev/guides/how-biome-works/#protected-files).
+  Biome emits a verbose warning when it encounters a protected file.
+
+  Previously, Biome emitted this verbose warning even if the file was ignored by the configuration.
+  Now, it doesn't emit verbose warnings for protected files that are ignored.
+
+  Contributed by @Conaclos
+
 - The file `biome.json` can't be ignored anymore. Contributed by @ematipico
+
 - Fix [#1541](https://github.com/biomejs/biome/issues/1541) where the content of protected files wasn't returned to `stdout`. Contributed by @ematipico
 
+- Don't handle CSS files, the formatter isn't ready yet. Contributed by @ematipico
+
 ### Configuration
 
 #### Bug fixes