diff --git a/packages/webview/src/component/pods/PodLogs.svelte b/packages/webview/src/component/pods/PodLogs.svelte
index dd17d026..07286ef1 100644
--- a/packages/webview/src/component/pods/PodLogs.svelte
+++ b/packages/webview/src/component/pods/PodLogs.svelte
@@ -1,14 +1,20 @@
 <script lang="ts">
-import type { V1Pod } from '@kubernetes/client-node';
-import { getContext, onDestroy, onMount, tick } from 'svelte';
-import { Streams } from '/@/stream/streams';
 import type { IDisposable } from '@kubernetes-dashboard/channels';
+import type { V1Pod } from '@kubernetes/client-node';
 import { EmptyScreen } from '@podman-desktop/ui-svelte';
-import NoLogIcon from '/@/component/icons/NoLogIcon.svelte';
 import type { Terminal } from '@xterm/xterm';
-import TerminalWindow from '/@/component/terminal/TerminalWindow.svelte';
+import { getContext, onDestroy, onMount, tick } from 'svelte';
 import { SvelteMap } from 'svelte/reactivity';
-import { ansi256Colours, colourizedANSIContainerName } from '/@/component/terminal/terminal-colors';
+import NoLogIcon from '/@/component/icons/NoLogIcon.svelte';
+import { detectJsonLogs } from '/@/component/terminal/json-colorizer';
+import {
+  ansi256Colours,
+  colorizeJSON,
+  colorizeLogLevel,
+  colourizedANSIContainerName,
+} from '/@/component/terminal/terminal-colors';
+import TerminalWindow from '/@/component/terminal/TerminalWindow.svelte';
+import { Streams } from '/@/stream/streams';
 
 interface Props {
   object: V1Pod;
@@ -18,6 +24,12 @@ let { object }: Props = $props();
 // Logs has been initialized
 let noLogs = $state(true);
 
+// Track if logs are JSON format (auto-detected from first 10 lines)
+let isJsonFormat = $state<boolean | undefined>(undefined);
+// TODO once we have a toolbar in logs we can add a checkbox/hamburger menu for this setting
+let shouldColorizeLogs = $state<boolean>(true);
+let logBuffer: string[] = [];
+
 let logsTerminal = $state<Terminal>();
 
 let disposables: IDisposable[] = [];
@@ -27,6 +39,50 @@ const streams = getContext<Streams>(Streams);
 // if we run out of colours, we'll start from the beginning.
 const colourizedContainerName = new SvelteMap<string, string>();
 
+/**
+ * Colorizes and formats log lines with optional container prefix.
+ * Applies log level colorization and JSON colorization (if detected).
+ *
+ * @param data - Raw log data from stream
+ * @param containerName - Name of the container (for multi-container pods)
+ * @param maxNameLength - Maximum container name length for padding (0 for single container)
+ * @returns Formatted and colorized log lines
+ */
+const colorizeAndFormatLogs = (data: string, containerName?: string, maxNameLength: number = 0): string => {
+  let lines = data.split('\n');
+
+  if (shouldColorizeLogs) {
+    // Auto-detect JSON format from first batch of logs
+    if (isJsonFormat === undefined) {
+      logBuffer.push(...lines.filter(l => l.trim()));
+      if (logBuffer.length >= 10) {
+        isJsonFormat = detectJsonLogs(logBuffer);
+        logBuffer = []; // Clear buffer after detection
+      }
+    }
+
+    // Apply colorization: JSON first (if detected/only a few lines of logs), then log levels
+    lines =
+      (isJsonFormat ?? true)
+        ? lines.map(line => colorizeLogLevel(colorizeJSON(line)))
+        : lines.map(line => colorizeLogLevel(line));
+  }
+
+  // Add container prefix for multi-container pods
+  if (containerName && maxNameLength > 0) {
+    const padding = ' '.repeat(maxNameLength - containerName.length);
+    const colouredName = colourizedContainerName.get(containerName);
+    // All lines are prefixed, except the last one if it's empty
+    return lines
+      .map((line, index, arr) =>
+        index < arr.length - 1 || line.length > 0 ? `${padding}${colouredName}|${line}` : line,
+      )
+      .join('\n');
+  }
+
+  return lines.join('\n');
+};
+
 onMount(async () => {
   logsTerminal?.clear();
 
@@ -45,23 +101,14 @@ onMount(async () => {
     });
   }
 
-  const multiContainers =
-    containerCount > 1
-      ? (name: string, data: string, callback: (data: string) => void): void => {
-          const padding = ' '.repeat(maxNameLength - name.length);
-          const colouredName = colourizedContainerName.get(name);
-
-          // All lines are prefixed, except the last one if it's empty.
-          const lines = data
-            .split('\n')
-            .map((line, index, arr) =>
-              index < arr.length - 1 || line.length > 0 ? `${padding}${colouredName}|${line}` : line,
-            );
-          callback(lines.join('\n'));
-        }
-      : (_name: string, data: string, callback: (data: string) => void): void => {
-          callback(data);
-        };
+  const processLogData = (containerName: string, data: string, callback: (data: string) => void): void => {
+    const formattedLogs = colorizeAndFormatLogs(
+      data,
+      containerCount > 1 ? containerName : undefined,
+      containerCount > 1 ? maxNameLength : 0,
+    );
+    callback(formattedLogs);
+  };
 
   for (const containerName of object.spec?.containers.map(c => c.name) ?? []) {
     disposables.push(
@@ -70,7 +117,7 @@ onMount(async () => {
         object.metadata?.namespace ?? '',
         containerName,
         chunk => {
-          multiContainers(containerName, chunk.data, data => {
+          processLogData(containerName, chunk.data, data => {
             if (noLogs) {
               noLogs = false;
             }
diff --git a/packages/webview/src/component/terminal/json-colorizer.spec.ts b/packages/webview/src/component/terminal/json-colorizer.spec.ts
new file mode 100644
index 00000000..f15d51e3
--- /dev/null
+++ b/packages/webview/src/component/terminal/json-colorizer.spec.ts
@@ -0,0 +1,355 @@
+/**********************************************************************
+ * Copyright (C) 2025 Red Hat, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ***********************************************************************/
+
+import { describe, expect, test } from 'vitest';
+
+import type { JsonColorScheme } from './json-colorizer.js';
+import { detectJsonLogs, JsonColorizer } from './json-colorizer.js';
+
+describe('JsonColorizer', () => {
+  const colorScheme: JsonColorScheme = {
+    braceColor: '\u001b[33m', // yellow
+    numberColor: '\u001b[32m', // green
+    booleanColor: '\u001b[35m', // magenta
+    nullColor: '\u001b[35m', // magenta
+    reset: '\u001b[0m',
+  };
+
+  const colorizer = new JsonColorizer(colorScheme);
+
+  test.each([
+    { jsonLine: '{"name": "test"}', open: '{', close: '}', desc: 'braces', strings: ['"name"', '"test"'] },
+    { jsonLine: '["item1", "item2"]', open: '[', close: ']', desc: 'brackets', strings: ['"item1"', '"item2"'] },
+    { jsonLine: '{}', open: '{', close: '}', desc: 'empty object', strings: [] },
+    { jsonLine: '[]', open: '[', close: ']', desc: 'empty array', strings: [] },
+  ])('should colorize $desc in yellow', ({ jsonLine, open, close, strings }) => {
+    const result = colorizer.colorize(jsonLine);
+
+    expect(result).toContain(`\u001b[33m${open}\u001b[0m`);
+    expect(result).toContain(`\u001b[33m${close}\u001b[0m`);
+
+    strings.forEach(str => expect(result).toContain(str));
+  });
+
+  test.each([
+    {
+      jsonLine: '{"count": 42, "price": 19.99}',
+      type: 'number',
+      coloredValues: ['\u001b[32m42\u001b[0m', '\u001b[32m19.99\u001b[0m'],
+      keys: ['"count"', '"price"'],
+    },
+    {
+      jsonLine: '{"enabled": true, "active": false}',
+      type: 'boolean',
+      coloredValues: ['\u001b[35mtrue\u001b[0m', '\u001b[35mfalse\u001b[0m'],
+      keys: ['"enabled"', '"active"'],
+    },
+    {
+      jsonLine: '{"value": null}',
+      type: 'null',
+      coloredValues: ['\u001b[35mnull\u001b[0m'],
+      keys: ['"value"'],
+    },
+    {
+      jsonLine: '{"value": 0}',
+      type: 'zero',
+      coloredValues: ['\u001b[32m0\u001b[0m'],
+      keys: ['"value"'],
+    },
+    {
+      jsonLine: '{"value": 0.5}',
+      type: 'decimal',
+      coloredValues: ['\u001b[32m0.5\u001b[0m'],
+      keys: ['"value"'],
+    },
+    {
+      jsonLine: '{"temperature": -15, "balance": -99.99}',
+      type: 'negative number',
+      coloredValues: ['\u001b[32m-15\u001b[0m', '\u001b[32m-99.99\u001b[0m'],
+      keys: ['"temperature"', '"balance"'],
+    },
+  ])('should colorize JSON with $type values', ({ jsonLine, coloredValues, keys }) => {
+    const result = colorizer.colorize(jsonLine);
+
+    expect(result).toContain('\u001b[33m{\u001b[0m');
+    expect(result).toContain('\u001b[33m}\u001b[0m');
+
+    coloredValues.forEach(value => expect(result).toContain(value));
+    keys.forEach(key => expect(result).toContain(key));
+  });
+
+  test.each([
+    {
+      jsonLine: '["item1", "item2", "item3"]',
+      type: 'strings',
+      expectedValues: ['"item1"', '"item2"', '"item3"'],
+    },
+    {
+      jsonLine: '[1, 2, 3, 4.5]',
+      type: 'numbers',
+      expectedValues: [
+        '\u001b[32m1\u001b[0m',
+        '\u001b[32m2\u001b[0m',
+        '\u001b[32m3\u001b[0m',
+        '\u001b[32m4.5\u001b[0m',
+      ],
+    },
+    {
+      jsonLine: '[true, false, true]',
+      type: 'booleans',
+      expectedValues: ['\u001b[35mtrue\u001b[0m', '\u001b[35mfalse\u001b[0m'],
+    },
+  ])('should colorize JSON array with $type', ({ jsonLine, expectedValues }) => {
+    const result = colorizer.colorize(jsonLine);
+
+    expect(result).toContain('\u001b[33m[\u001b[0m');
+    expect(result).toContain('\u001b[33m]\u001b[0m');
+
+    expectedValues.forEach(value => expect(result).toContain(value));
+  });
+
+  test('should colorize complex nested JSON', () => {
+    const jsonLine = '{"user": {"name": "John", "age": 30, "active": true}}';
+    const result = colorizer.colorize(jsonLine);
+
+    // Braces should be yellow (4 total: outer { }, inner { })
+    expect(result).toContain('\u001b[33m{\u001b[0m');
+    expect(result).toContain('\u001b[33m}\u001b[0m');
+
+    // Values should be appropriately colored
+    expect(result).toContain('\u001b[32m30\u001b[0m');
+    expect(result).toContain('\u001b[35mtrue\u001b[0m');
+
+    // Strings should not be colorized
+    expect(result).toContain('"user"');
+    expect(result).toContain('"name"');
+    expect(result).toContain('"age"');
+    expect(result).toContain('"active"');
+    expect(result).toContain('"John"');
+  });
+
+  test('should colorize JSON log level format', () => {
+    const jsonLine = '{"timestamp":"123","level":"information","message":"test"}';
+    const result = colorizer.colorize(jsonLine);
+
+    // Braces should be yellow
+    expect(result).toContain('\u001b[33m{\u001b[0m');
+    expect(result).toContain('\u001b[33m}\u001b[0m');
+
+    // Strings should not be colorized
+    expect(result).toContain('"timestamp"');
+    expect(result).toContain('"level"');
+    expect(result).toContain('"message"');
+    expect(result).toContain('"123"');
+    expect(result).toContain('"information"');
+    expect(result).toContain('"test"');
+  });
+
+  test('should colorize JSON with mixed types in array', () => {
+    const jsonLine = '["text", 123, true, null]';
+    const result = colorizer.colorize(jsonLine);
+
+    // Brackets should be yellow
+    expect(result).toContain('\u001b[33m[\u001b[0m');
+    expect(result).toContain('\u001b[33m]\u001b[0m');
+
+    // Each type should be colorized appropriately
+    expect(result).toContain('"text"'); // strings not colorized
+    expect(result).toContain('\u001b[32m123\u001b[0m');
+    expect(result).toContain('\u001b[35mtrue\u001b[0m');
+    expect(result).toContain('\u001b[35mnull\u001b[0m');
+  });
+
+  test('should handle JSON with escaped quotes', () => {
+    const jsonLine = '{"message": "He said \\"hello\\""}';
+    const result = colorizer.colorize(jsonLine);
+
+    // Braces should be yellow
+    expect(result).toContain('\u001b[33m{\u001b[0m');
+    expect(result).toContain('\u001b[33m}\u001b[0m');
+
+    // Should handle escaped quotes properly - strings not colorized
+    expect(result).toContain('"message"');
+    expect(result).toContain('"He said \\"hello\\""');
+  });
+
+  test('should work with custom color scheme', () => {
+    const customScheme: JsonColorScheme = {
+      braceColor: '\u001b[31m', // red
+      numberColor: '\u001b[33m', // yellow
+      booleanColor: '\u001b[34m', // blue
+      nullColor: '\u001b[35m', // magenta
+      reset: '\u001b[0m',
+    };
+
+    const customColorizer = new JsonColorizer(customScheme);
+    const jsonLine = '{"key": "value", "num": 42, "flag": true, "empty": null}';
+    const result = customColorizer.colorize(jsonLine);
+
+    // Should use custom colors
+    expect(result).toContain('\u001b[31m{\u001b[0m'); // red braces
+    expect(result).toContain('\u001b[31m}\u001b[0m'); // red braces
+    expect(result).toContain('\u001b[33m42\u001b[0m'); // yellow number
+    expect(result).toContain('\u001b[34mtrue\u001b[0m'); // blue boolean
+    expect(result).toContain('\u001b[35mnull\u001b[0m'); // magenta null
+
+    // Strings should not be colorized
+    expect(result).toContain('"key"');
+    expect(result).toContain('"value"');
+  });
+});
+
+describe('detectJsonLogs', () => {
+  test('should detect JSON logs when 80% or more lines are valid JSON', () => {
+    const logs = [
+      '{"timestamp":"2025-11-18T10:00:00Z","level":"info","message":"Starting application"}',
+      '{"timestamp":"2025-11-18T10:00:01Z","level":"info","message":"Connected to database"}',
+      '{"timestamp":"2025-11-18T10:00:02Z","level":"info","message":"Server listening on port 8080"}',
+      '{"timestamp":"2025-11-18T10:00:03Z","level":"debug","message":"Request received"}',
+      '{"timestamp":"2025-11-18T10:00:04Z","level":"debug","message":"Processing request"}',
+      '{"timestamp":"2025-11-18T10:00:05Z","level":"info","message":"Request completed"}',
+      '{"timestamp":"2025-11-18T10:00:06Z","level":"info","message":"Cache updated"}',
+      '{"timestamp":"2025-11-18T10:00:07Z","level":"info","message":"Background job started"}',
+      'Not a JSON line',
+      '{"timestamp":"2025-11-18T10:00:08Z","level":"info","message":"Job completed"}',
+    ];
+
+    expect(detectJsonLogs(logs)).toBe(true);
+  });
+
+  test('should not detect JSON logs when less than 80% are valid JSON', () => {
+    const logs = [
+      '{"timestamp":"2025-11-18T10:00:00Z","level":"info","message":"Starting"}',
+      '{"timestamp":"2025-11-18T10:00:01Z","level":"info","message":"Running"}',
+      'Regular log line without JSON',
+      'Another regular log line',
+      'Yet another non-JSON line',
+      'Still not JSON',
+      'Nope, not JSON either',
+      '{"timestamp":"2025-11-18T10:00:02Z","level":"info","message":"Done"}',
+      'More regular logs',
+      'Last regular log',
+    ];
+
+    expect(detectJsonLogs(logs)).toBe(false);
+  });
+
+  test('should handle empty log array', () => {
+    expect(detectJsonLogs([])).toBe(false);
+  });
+
+  test('should ignore empty lines when calculating ratio', () => {
+    const logs = [
+      '{"timestamp":"2025-11-18T10:00:00Z","level":"info","message":"Line 1"}',
+      '',
+      '{"timestamp":"2025-11-18T10:00:01Z","level":"info","message":"Line 2"}',
+      '',
+      '{"timestamp":"2025-11-18T10:00:02Z","level":"info","message":"Line 3"}',
+      '',
+      '{"timestamp":"2025-11-18T10:00:03Z","level":"info","message":"Line 4"}',
+      '',
+      '{"timestamp":"2025-11-18T10:00:04Z","level":"info","message":"Line 5"}',
+      '',
+      '{"timestamp":"2025-11-18T10:00:05Z","level":"info","message":"Line 6"}',
+      '',
+      '{"timestamp":"2025-11-18T10:00:06Z","level":"info","message":"Line 7"}',
+      '',
+      '{"timestamp":"2025-11-18T10:00:07Z","level":"info","message":"Line 8"}',
+      '',
+    ];
+
+    expect(detectJsonLogs(logs)).toBe(true);
+  });
+
+  test('should only check first 10 non-empty lines', () => {
+    const logs = [
+      '{"timestamp":"2025-11-18T10:00:00Z","level":"info","message":"Line 1"}',
+      '{"timestamp":"2025-11-18T10:00:01Z","level":"info","message":"Line 2"}',
+      '{"timestamp":"2025-11-18T10:00:02Z","level":"info","message":"Line 3"}',
+      '{"timestamp":"2025-11-18T10:00:03Z","level":"info","message":"Line 4"}',
+      '{"timestamp":"2025-11-18T10:00:04Z","level":"info","message":"Line 5"}',
+      '{"timestamp":"2025-11-18T10:00:05Z","level":"info","message":"Line 6"}',
+      '{"timestamp":"2025-11-18T10:00:06Z","level":"info","message":"Line 7"}',
+      '{"timestamp":"2025-11-18T10:00:07Z","level":"info","message":"Line 8"}',
+      '{"timestamp":"2025-11-18T10:00:08Z","level":"info","message":"Line 9"}',
+      '{"timestamp":"2025-11-18T10:00:09Z","level":"info","message":"Line 10"}',
+      // These lines after the 10th should be ignored
+      'Not JSON line 11',
+      'Not JSON line 12',
+      'Not JSON line 13',
+    ];
+
+    expect(detectJsonLogs(logs)).toBe(true);
+  });
+
+  test('should detect JSON with nested objects', () => {
+    const logs = [
+      '{"user":{"id":123,"name":"John"},"action":"login"}',
+      '{"user":{"id":124,"name":"Jane"},"action":"logout"}',
+      '{"data":{"key":"value","nested":{"deep":"data"}},"timestamp":"2025-11-18"}',
+      '{"array":[1,2,3],"object":{"a":"b"}}',
+      '{"simple":"test","number":42}',
+      '{"bool":true,"null":null}',
+      '{"str":"value","num":123}',
+      '{"x":1,"y":2}',
+      '{"foo":"bar"}',
+      '{"last":"one"}',
+    ];
+
+    expect(detectJsonLogs(logs)).toBe(true);
+  });
+
+  test('should not detect lines with braces but no key-value pairs', () => {
+    const logs = [
+      'Processing {item}',
+      'Found {value} in cache',
+      'Error: {error message}',
+      'Debug: {info}',
+      'Status: {ok}',
+      'Result: {success}',
+      'Output: {data}',
+      'Input: {params}',
+      'Config: {settings}',
+      'State: {ready}',
+    ];
+
+    expect(detectJsonLogs(logs)).toBe(false);
+  });
+
+  test.each([
+    {
+      desc: 'exactly 80% threshold',
+      jsonCount: 8,
+      nonJsonCount: 2,
+      expected: true,
+    },
+    {
+      desc: 'just below 80% threshold',
+      jsonCount: 7,
+      nonJsonCount: 3,
+      expected: false,
+    },
+  ])('should detect $desc', ({ jsonCount, nonJsonCount, expected }) => {
+    const logs = [
+      ...Array.from({ length: jsonCount }, (_, i) => `{"valid":"json","line":${i + 1}}`),
+      ...Array.from({ length: nonJsonCount }, (_, i) => `Not JSON line ${jsonCount + i + 1}`),
+    ];
+
+    expect(detectJsonLogs(logs)).toBe(expected);
+  });
+});
diff --git a/packages/webview/src/component/terminal/json-colorizer.ts b/packages/webview/src/component/terminal/json-colorizer.ts
new file mode 100644
index 00000000..6c7961be
--- /dev/null
+++ b/packages/webview/src/component/terminal/json-colorizer.ts
@@ -0,0 +1,254 @@
+/**********************************************************************
+ * Copyright (C) 2025 Red Hat, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ***********************************************************************/
+
+export interface JsonColorScheme {
+  keyColor?: string; // Color for object keys (optional)
+  stringColor?: string; // Color for string values (optional)
+  braceColor?: string; // Color for braces/brackets (optional)
+  numberColor?: string; // Color for numbers (optional)
+  booleanColor?: string; // Color for booleans (optional)
+  nullColor?: string; // Color for null (optional)
+  reset: string; // Reset code (required)
+}
+
+interface ProcessResult {
+  text: string;
+  nextIndex: number;
+}
+
+/**
+ * A class for colorizing JSON strings with ANSI escape codes.
+ * Supports customizable color schemes for keys, values, numbers, booleans, and null.
+ */
+export class JsonColorizer {
+  constructor(private readonly colorScheme: JsonColorScheme) {}
+
+  /**
+   * Colorizes a JSON string with ANSI color codes.
+   * Processes the string character by character to avoid escape code conflicts.
+   *
+   * @param jsonLine - The JSON string to colorize
+   * @returns The colorized JSON string with ANSI codes
+   */
+  colorize(jsonLine: string): string {
+    let result = '';
+    let i = 0;
+    let isAfterColon = false;
+
+    while (i < jsonLine.length) {
+      const char = jsonLine[i];
+
+      // Handle structural characters
+      const structuralResult = this.handleStructuralChar(char, isAfterColon);
+      if (structuralResult !== undefined) {
+        result += structuralResult.text;
+        isAfterColon = structuralResult.isAfterColon;
+        i++;
+        continue;
+      }
+
+      // Handle quoted strings (keys or values)
+      if (char === '"') {
+        const stringResult = this.processString(jsonLine, i, isAfterColon);
+        result += stringResult.text;
+        i = stringResult.nextIndex;
+        continue;
+      }
+
+      // Handle numbers
+      if (this.isNumberStart(jsonLine, i)) {
+        const numberResult = this.processNumber(jsonLine, i);
+        result += numberResult.text;
+        i = numberResult.nextIndex;
+        continue;
+      }
+
+      // Handle keywords (boolean/null)
+      const keywordResult = this.processKeyword(jsonLine, i);
+      if (keywordResult) {
+        result += keywordResult.text;
+        i = keywordResult.nextIndex;
+        continue;
+      }
+
+      // Regular character
+      result += char;
+      i++;
+    }
+
+    return result;
+  }
+
+  private handleStructuralChar(
+    char: string,
+    _isAfterColon: boolean,
+  ): { text: string; isAfterColon: boolean } | undefined {
+    // Handle braces and brackets
+    if (char === '{' || char === '}' || char === '[' || char === ']') {
+      const text = this.colorScheme.braceColor ? this.colorScheme.braceColor + char + this.colorScheme.reset : char;
+      return { text, isAfterColon: false };
+    }
+
+    // Track colon to distinguish keys from values
+    if (char === ':') {
+      return { text: char, isAfterColon: true };
+    }
+
+    // Track comma to reset key/value state
+    if (char === ',') {
+      return { text: char, isAfterColon: false };
+    }
+
+    return undefined;
+  }
+
+  private processString(jsonLine: string, startIndex: number, isAfterColon: boolean): ProcessResult {
+    const stringEnd = this.findStringEnd(jsonLine, startIndex);
+    const stringContent = jsonLine.substring(startIndex, stringEnd);
+
+    // Determine if this is a key (before colon) or value (after colon)
+    const isKey = !isAfterColon;
+    const colorToUse = isKey ? this.colorScheme.keyColor : this.colorScheme.stringColor;
+
+    const text = colorToUse ? colorToUse + stringContent + this.colorScheme.reset : stringContent;
+
+    return {
+      text,
+      nextIndex: stringEnd,
+    };
+  }
+
+  private findStringEnd(jsonLine: string, startIndex: number): number {
+    let i = startIndex + 1; // Skip opening quote
+
+    // Find closing quote (handle escaped quotes)
+    while (i < jsonLine.length && (jsonLine[i] !== '"' || jsonLine[i - 1] === '\\')) {
+      i++;
+    }
+    i++; // Include closing quote
+
+    return i;
+  }
+
+  private isNumberStart(jsonLine: string, index: number): boolean {
+    const char = jsonLine[index];
+    const isDigitOrMinus = /[\d-]/.test(char);
+    if (!isDigitOrMinus) return false;
+
+    // Check if we're in a number context
+    for (let k = index - 1; k >= 0; k--) {
+      const prevChar = jsonLine[k];
+      if (/\s/.test(prevChar)) continue;
+      return prevChar === ':' || prevChar === '[' || prevChar === ',';
+    }
+    return false;
+  }
+
+  private processNumber(jsonLine: string, startIndex: number): ProcessResult {
+    let i = startIndex;
+    if (jsonLine[i] === '-') i++;
+
+    while (i < jsonLine.length && /[\d.]/.test(jsonLine[i])) {
+      i++;
+    }
+
+    const number = jsonLine.substring(startIndex, i);
+    const text = this.colorScheme.numberColor ? this.colorScheme.numberColor + number + this.colorScheme.reset : number;
+    return {
+      text,
+      nextIndex: i,
+    };
+  }
+
+  private processKeyword(jsonLine: string, startIndex: number): ProcessResult | undefined {
+    // Handle boolean values
+    if (jsonLine.substring(startIndex, startIndex + 4) === 'true') {
+      const text = this.colorScheme.booleanColor
+        ? this.colorScheme.booleanColor + 'true' + this.colorScheme.reset
+        : 'true';
+      return {
+        text,
+        nextIndex: startIndex + 4,
+      };
+    }
+
+    if (jsonLine.substring(startIndex, startIndex + 5) === 'false') {
+      const text = this.colorScheme.booleanColor
+        ? this.colorScheme.booleanColor + 'false' + this.colorScheme.reset
+        : 'false';
+      return {
+        text,
+        nextIndex: startIndex + 5,
+      };
+    }
+
+    // Handle null
+    if (jsonLine.substring(startIndex, startIndex + 4) === 'null') {
+      const text = this.colorScheme.nullColor ? this.colorScheme.nullColor + 'null' + this.colorScheme.reset : 'null';
+      return {
+        text,
+        nextIndex: startIndex + 4,
+      };
+    }
+
+    return undefined;
+  }
+}
+
+/**
+ * Checks if a string appears to be valid JSON.
+ * A valid JSON line should have both { and } and contain at least one key-value pair pattern.
+ *
+ * @param line - The line to check
+ * @returns true if the line appears to be JSON
+ */
+export function isValidJSON(line: string): boolean {
+  const trimmed = line.trim();
+  if (!trimmed) return false;
+
+  // Check for basic JSON structure: has { and } and contains key-value patterns
+  const hasBraces = trimmed.includes('{') && trimmed.includes('}');
+  if (!hasBraces) return false;
+
+  // Look for key-value pair pattern: "key": value or "key":value
+  const kvpPattern = /"[^"]+"\s*:\s*[^,}]+/;
+  return kvpPattern.test(trimmed);
+}
+
+/**
+ * Detects if log lines are predominantly JSON format.
+ * Checks the first 10 non-empty lines and returns true if at least 80% are valid JSON.
+ *
+ * @param lines - Array of log lines to analyze
+ * @returns true if logs should be treated as JSON format
+ */
+export function detectJsonLogs(lines: string[]): boolean {
+  const samplesToCheck = 10;
+  const threshold = 0.8; // 80%
+
+  // Filter out empty lines and take first 10
+  const nonEmptyLines = lines.filter(line => line.trim().length > 0).slice(0, samplesToCheck);
+
+  // Need at least a few lines to make a determination
+  if (nonEmptyLines.length === 0) return false;
+
+  const jsonCount = nonEmptyLines.filter(line => isValidJSON(line)).length;
+  const jsonRatio = jsonCount / nonEmptyLines.length;
+
+  return jsonRatio >= threshold;
+}
diff --git a/packages/webview/src/component/terminal/terminal-colors.spec.ts b/packages/webview/src/component/terminal/terminal-colors.spec.ts
new file mode 100644
index 00000000..4eb148e3
--- /dev/null
+++ b/packages/webview/src/component/terminal/terminal-colors.spec.ts
@@ -0,0 +1,165 @@
+/**********************************************************************
+ * Copyright (C) 2025 Red Hat, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ***********************************************************************/
+
+import { describe, expect, test } from 'vitest';
+
+import { colorizeJSON, colorizeLogLevel } from './terminal-colors.js';
+
+describe('colorizeLogLevel', () => {
+  test.each([
+    {
+      logLine: '[23:10:06 INF] Starting application',
+      color: '\u001b[36m',
+      message: 'Starting application',
+      level: 'INFO',
+    },
+    { logLine: '[DBG] Debug message', color: '\u001b[32m', message: 'Debug message', level: 'DEBUG' },
+    { logLine: '[ERROR] Something went wrong', color: '\u001b[31', message: 'Something went wrong', level: 'ERROR' },
+    { logLine: '[12:34:56 WARN] Warning message', color: '\u001b[33m', message: 'Warning message', level: 'WARN' },
+    { logLine: '[FATAL] Critical error', color: '\u001b[31m', message: 'Critical error', level: 'FATAL' },
+    { logLine: '[TRACE] Trace information', color: '\u001b[36;1m', message: 'Trace information', level: 'TRACE' },
+  ])('should colorize $level log level', ({ logLine, color, message }) => {
+    const result = colorizeLogLevel(logLine);
+
+    expect(result).toContain(color);
+    expect(result).toContain('\u001b[0m');
+    expect(result).toContain(message);
+  });
+
+  test('should handle log line with Kubernetes timestamp prefix', () => {
+    const logLine = '2025-10-29T23:10:10.688386132-05:00 [23:10:10 INF] Server started';
+    const result = colorizeLogLevel(logLine);
+
+    // Should preserve the K8s timestamp
+    expect(result).toContain('2025-10-29T23:10:10.688386132-05:00');
+    // Should colorize the INFO level
+    expect(result).toContain('\u001b[36m');
+    expect(result).toContain('Server started');
+  });
+
+  test.each([
+    { input: '[info] lowercase info', level: 'lowercase' },
+    { input: '[Info] Mixed case info', level: 'mixed case' },
+  ])('should handle $level log levels', ({ input }) => {
+    const result = colorizeLogLevel(input);
+    expect(result).toContain('\u001b[36m');
+  });
+
+  test.each([
+    { input: '[INF] Info message', color: '\u001b[36m', level: 'INF' },
+    { input: '[WRN] Warning message', color: '\u001b[33m', level: 'WRN' },
+    { input: '[ERR] Error message', color: '\u001b[31', level: 'ERR' },
+  ])('should handle abbreviated log level $level', ({ input, color }) => {
+    const result = colorizeLogLevel(input);
+    expect(result).toContain(color);
+  });
+
+  test('should handle log level in middle of line', () => {
+    const logLine = 'prefix content [23:10:06 INFO] message after bracket';
+    const result = colorizeLogLevel(logLine);
+
+    // Should preserve prefix
+    expect(result).toContain('prefix content');
+    // Should colorize INFO
+    expect(result).toContain('\u001b[36m');
+    // Should preserve suffix
+    expect(result).toContain('message after bracket');
+  });
+
+  test('should not modify line without log level', () => {
+    const logLine = 'This is a regular log line without level';
+    const result = colorizeLogLevel(logLine);
+
+    // Should return the line unchanged
+    expect(result).toBe(logLine);
+  });
+
+  test('should not modify line with text in brackets that is not a log level', () => {
+    const logLine = '[NOTLEVEL] This is not a log level';
+    const result = colorizeLogLevel(logLine);
+
+    // Should return the line unchanged
+    expect(result).toBe(logLine);
+  });
+
+  test.each([
+    { input: '[DEBUG] Debug message', color: '\u001b[32m', level: 'DEBUG' },
+    { input: '[INFO] Info message', color: '\u001b[36m', level: 'INFO' },
+    { input: '[WARNING] Warning message', color: '\u001b[33m', level: 'WARNING' },
+    { input: '[ERROR] Error message', color: '\u001b[31', level: 'ERROR' },
+  ])('should handle full word log level $level', ({ input, color }) => {
+    const result = colorizeLogLevel(input);
+    expect(result).toContain(color);
+  });
+
+  test('should only colorize the first log level found', () => {
+    const logLine = '[INFO] Found another [ERROR] in message';
+    const result = colorizeLogLevel(logLine);
+
+    // Should colorize INFO (first match)
+    expect(result).toContain('\u001b[36m');
+    // Count how many times we see the reset code - should only be once
+    // eslint-disable-next-line sonarjs/no-control-regex, no-control-regex
+    const resetCount = (result.match(/\u001b\[0m/g) ?? []).length;
+    expect(resetCount).toBe(1);
+  });
+
+  test('should preserve exact format of brackets and timestamp', () => {
+    const logLine = '[23:10:06 INFO] Message';
+    const result = colorizeLogLevel(logLine);
+
+    // The timestamp and brackets should still be present
+    expect(result).toMatch(/23:10:06/);
+    expect(result).toMatch(/INFO/);
+  });
+
+  test('should colorize colon format log level', () => {
+    const logLine = 'info: mylog';
+    const result = colorizeLogLevel(logLine);
+
+    // Should contain cyan ANSI code for info
+    expect(result).toContain('\u001b[36m');
+    expect(result).toContain('\u001b[0m');
+    expect(result).toContain('mylog');
+  });
+
+  test('should colorize JSON format with quoted level', () => {
+    const logLine = '{"timestamp":"123","level":"information","message":"test"}';
+    const result = colorizeLogLevel(logLine);
+
+    // Should contain cyan ANSI code for information
+    expect(result).toContain('\u001b[36m');
+    expect(result).toContain('\u001b[0m');
+    expect(result).toContain('"information"');
+  });
+
+  test('should work with JSON colorization function', () => {
+    const jsonLine = '{"level":"info","message":"test"}';
+    const result = colorizeJSON(jsonLine);
+
+    // Should colorize braces in yellow
+    expect(result).toContain('\u001b[33m{\u001b[0m');
+    expect(result).toContain('\u001b[33m}\u001b[0m');
+
+    // Strings should not be colorized
+    expect(result).toContain('"level"');
+    expect(result).toContain('"info"');
+    expect(result).toContain('"message"');
+    expect(result).toContain('"test"');
+  });
+});
diff --git a/packages/webview/src/component/terminal/terminal-colors.ts b/packages/webview/src/component/terminal/terminal-colors.ts
index 11d50efc..ef445712 100644
--- a/packages/webview/src/component/terminal/terminal-colors.ts
+++ b/packages/webview/src/component/terminal/terminal-colors.ts
@@ -16,6 +16,9 @@
  * SPDX-License-Identifier: Apache-2.0
  ***********************************************************************/
 
+import type { JsonColorScheme } from './json-colorizer.js';
+import { JsonColorizer } from './json-colorizer.js';
+
 // An array of readable ANSI escape sequence colours against a black terminal background
 // these are the most "readable" colours against a black background
 // No colours like grey, normal blue (cyan instead) or red, since they don't appear very well.
@@ -32,8 +35,113 @@ export const ansi256Colours = [
   '\u001b[34;1m', // bright blue
 ];
 
+// ANSI colors for log levels
+const LOG_LEVEL_COLORS: Record<string, string> = {
+  TRACE: '\u001b[36;1m', // bright cyan
+  DBG: '\u001b[32m', // green
+  DEBUG: '\u001b[32m',
+  INF: '\u001b[36m', // cyan
+  INFO: '\u001b[36m',
+  INFORMATION: '\u001b[36m',
+  WRN: '\u001b[33m', // yellow
+  WARN: '\u001b[33m',
+  WARNING: '\u001b[33m',
+  ERR: '\u001b[31;1m', // bright red
+  ERROR: '\u001b[31m;1m',
+  FATAL: '\u001b[31m', // bright red
+};
+
 // Function that takes the container name and ANSI colour and encapsulates the name in the colour,
 // making sure that we reset the colour back to white after the name.
 export function colourizedANSIContainerName(name: string, colour: string): string {
   return `${colour}${name}\u001b[0m`;
 }
+
+/**
+ * Colorizes log levels in brackets for better readability.
+ * Detects patterns like [timestamp LEVEL] or [LEVEL] or LEVEL: or (LEVEL) or "LEVEL" anywhere in the line.
+ *
+ * Examples:
+ * - [23:10:06 INF] -> cyan
+ * - [DBG] -> green
+ * - [ERROR] -> bright red
+ * - info: message -> cyan
+ * - (INFO) message -> cyan
+ * - "WARN" message -> yellow
+ * - "information" -> cyan
+ * - 2025-10-29T23:10:10.688386132-05:00 info: message -> cyan (with timestamp)
+ * - 2025-10-29T23:10:10.688386132-05:00 [23:10:10 INF] -> cyan (with K8s timestamp)
+ */
+export function colorizeLogLevel(logLine: string): string {
+  const levelNames = 'DBG|DEBUG|INF|INFO|INFORMATION|WRN|WARN|WARNING|ERR|ERROR|FATAL|TRACE';
+  // Combined pattern: Match [timestamp? LEVEL], LEVEL:, (LEVEL), or "LEVEL" anywhere in the line
+  const logLevelPattern = new RegExp(
+    `((\\[(?:[0-9:]+\\s+)?)(${levelNames})(\\])|(${levelNames})(:)|(\\()(${levelNames})(\\))|(")(${levelNames})("))`,
+    'i',
+  );
+
+  const match = logLevelPattern.exec(logLine);
+  if (match) {
+    const before = logLine.slice(0, match.index);
+    const rest = logLine.slice(match.index + match[0].length);
+
+    // Check which format matched
+    if (match[2]) {
+      // Bracket format: [timestamp? LEVEL]
+      const prefix = match[2]; // [timestamp or [
+      const level = match[3]; // Keep original case
+      const suffix = match[4]; // ]
+      const color = LOG_LEVEL_COLORS[level.toUpperCase()] || '\u001b[37m';
+      return `${before}${color}${prefix}${level}${suffix}\u001b[0m${rest}`;
+    } else if (match[5]) {
+      // Colon format: LEVEL:
+      const level = match[5]; // Keep original case
+      const colon = match[6];
+      const color = LOG_LEVEL_COLORS[level.toUpperCase()] || '\u001b[37m';
+      return `${before}${color}${level}${colon}\u001b[0m${rest}`;
+    } else if (match[7]) {
+      // Parenthesis format: (LEVEL)
+      const openParen = match[7];
+      const level = match[8]; // Keep original case
+      const closeParen = match[9];
+      const color = LOG_LEVEL_COLORS[level.toUpperCase()] || '\u001b[37m';
+      return `${before}${color}${openParen}${level}${closeParen}\u001b[0m${rest}`;
+    } else if (match[10]) {
+      // Quote format: "LEVEL"
+      const openQuote = match[10];
+      const level = match[11]; // Keep original case
+      const closeQuote = match[12];
+      const color = LOG_LEVEL_COLORS[level.toUpperCase()] || '\u001b[37m';
+      return `${before}${color}${openQuote}${level}${closeQuote}\u001b[0m${rest}`;
+    }
+  }
+
+  return logLine;
+}
+
+// Create a default JSON colorizer instance
+const defaultJsonColorScheme: JsonColorScheme = {
+  keyColor: '\u001b[34;1m', // bright blue for keys
+  braceColor: '\u001b[33m', // yellow for {}[]
+  numberColor: '\u001b[32m', // green for numbers
+  booleanColor: '\u001b[35m', // magenta for booleans
+  nullColor: '\u001b[35m', // magenta for null
+  reset: '\u001b[0m',
+};
+
+const defaultJsonColorizer = new JsonColorizer(defaultJsonColorScheme);
+
+/**
+ * Colorizes JSON strings for terminal display.
+ * Applies ANSI colors to improve readability.
+ *
+ * Color scheme:
+ * - Keys: bright blue
+ * - Braces/brackets: yellow
+ * - Numbers: green
+ * - Booleans/null: magenta
+ * - String values: no colorization (optional)
+ */
+export function colorizeJSON(jsonLine: string): string {
+  return defaultJsonColorizer.colorize(jsonLine);
+}