diff --git a/DevProxy.Abstractions/Proxy/IProxyConfiguration.cs b/DevProxy.Abstractions/Proxy/IProxyConfiguration.cs
index ab6d084f..6171dccd 100644
--- a/DevProxy.Abstractions/Proxy/IProxyConfiguration.cs
+++ b/DevProxy.Abstractions/Proxy/IProxyConfiguration.cs
@@ -18,6 +18,14 @@ public enum ReleaseType
     Beta
 }
 
+public enum LogFor
+{
+    [EnumMember(Value = "human")]
+    Human,
+    [EnumMember(Value = "machine")]
+    Machine
+}
+
 public interface IProxyConfiguration
 {
     int ApiPort { get; set; }
@@ -29,6 +37,7 @@ public interface IProxyConfiguration
     IEnumerable<MockRequestHeader>? FilterByHeaders { get; }
     bool InstallCert { get; set; }
     string? IPAddress { get; set; }
+    LogFor LogFor { get; }
     LogLevel LogLevel { get; }
     ReleaseType NewVersionNotification { get; }
     bool NoFirstRun { get; set; }
diff --git a/DevProxy.Plugins/SharePoint/CsomParser.cs b/DevProxy.Plugins/SharePoint/CsomParser.cs
index 9557d985..262aac1b 100644
--- a/DevProxy.Plugins/SharePoint/CsomParser.cs
+++ b/DevProxy.Plugins/SharePoint/CsomParser.cs
@@ -80,7 +80,7 @@ public static (IEnumerable<string> Actions, IEnumerable<string> Errors) GetActio
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"Error parsing XML: {ex.Message}");
+            errors.Add($"Error parsing XML: {ex.Message}");
         }
 
         return (actions, errors);
diff --git a/DevProxy/Commands/DevProxyCommand.cs b/DevProxy/Commands/DevProxyCommand.cs
index b41848f0..032e0e2b 100644
--- a/DevProxy/Commands/DevProxyCommand.cs
+++ b/DevProxy/Commands/DevProxyCommand.cs
@@ -37,6 +37,7 @@ sealed class DevProxyCommand : RootCommand
     internal const string TimeoutOptionName = "--timeout";
     internal const string DiscoverOptionName = "--discover";
     internal const string EnvOptionName = "--env";
+    internal const string LogForOptionName = "--log-for";
 
     private static readonly string[] globalOptions = ["--version"];
     private static readonly string[] helpOptions = ["--help", "-h", "/h", "-?", "/?"];
@@ -396,6 +397,24 @@ private void ConfigureCommand()
             }
         });
 
+        var logForOption = new Option<LogFor?>(LogForOptionName)
+        {
+            Description = $"Target audience for log output. Allowed values: {string.Join(", ", Enum.GetNames<LogFor>())}",
+            HelpName = "log-for",
+            Recursive = true
+        };
+        logForOption.Validators.Add(input =>
+        {
+            if (input.Tokens.Count == 0)
+            {
+                return;
+            }
+            if (!Enum.TryParse<LogFor>(input.Tokens[0].Value, true, out _))
+            {
+                input.AddError($"{input.Tokens[0].Value} is not a valid log-for value. Allowed values are: {string.Join(", ", Enum.GetNames<LogFor>())}");
+            }
+        });
+
         var options = new List<Option>
         {
             apiPortOption,
@@ -405,6 +424,7 @@ private void ConfigureCommand()
             envOption,
             installCertOption,
             ipAddressOption,
+            logForOption,
             logLevelOption,
             noFirstRunOption,
             portOption,
diff --git a/DevProxy/Commands/DevProxyConfigOptions.cs b/DevProxy/Commands/DevProxyConfigOptions.cs
index 7b0264b3..658ddba5 100644
--- a/DevProxy/Commands/DevProxyConfigOptions.cs
+++ b/DevProxy/Commands/DevProxyConfigOptions.cs
@@ -1,3 +1,4 @@
+using DevProxy.Abstractions.Proxy;
 using DevProxy.Abstractions.Utils;
 using System.CommandLine;
 using System.CommandLine.Parsing;
@@ -20,6 +21,7 @@ public string? ConfigFile
     public int? ApiPort => _parseResult?.GetValueOrDefault<int?>(DevProxyCommand.ApiPortOptionName);
     public bool Discover => _parseResult?.GetValueOrDefault<bool?>(DevProxyCommand.DiscoverOptionName) ?? false;
     public string? IPAddress => _parseResult?.GetValueOrDefault<string?>(DevProxyCommand.IpAddressOptionName);
+    public LogFor? LogFor => _parseResult?.GetValueOrDefault<LogFor?>(DevProxyCommand.LogForOptionName);
     public LogLevel? LogLevel => _parseResult?.GetValueOrDefault<LogLevel?>(DevProxyCommand.LogLevelOptionName);
 
     public List<string>? UrlsToWatch
@@ -114,6 +116,25 @@ public DevProxyConfigOptions()
                 }
             }
         };
+
+        var logForOption = new Option<LogFor?>(DevProxyCommand.LogForOptionName)
+        {
+            CustomParser = result =>
+            {
+                if (!result.Tokens.Any())
+                {
+                    return null;
+                }
+
+                if (Enum.TryParse<LogFor>(result.Tokens[0].Value, true, out var logFor))
+                {
+                    return logFor;
+                }
+
+                return null;
+            }
+        };
+
         var apiPortOption = new Option<int?>(DevProxyCommand.ApiPortOptionName);
 
         var discoverOption = new Option<bool>(DevProxyCommand.DiscoverOptionName, "--discover")
@@ -127,6 +148,7 @@ public DevProxyConfigOptions()
             ipAddressOption,
             configFileOption,
             urlsToWatchOption,
+            logForOption,
             logLevelOption,
             discoverOption
         };
diff --git a/DevProxy/Extensions/ILoggingBuilderExtensions.cs b/DevProxy/Extensions/ILoggingBuilderExtensions.cs
index 32c26fe4..7e3e6a20 100644
--- a/DevProxy/Extensions/ILoggingBuilderExtensions.cs
+++ b/DevProxy/Extensions/ILoggingBuilderExtensions.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using DevProxy.Abstractions.Proxy;
 using DevProxy.Commands;
 using DevProxy.Logging;
 
@@ -26,6 +27,10 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
         var configuredLogLevel = options.LogLevel ??
             configuration.GetValue("logLevel", LogLevel.Information);
 
+        // Determine the log target audience (human or machine)
+        var configuredLogFor = options.LogFor ??
+            configuration.GetValue("logFor", LogFor.Human);
+
         // For stdio command, log to file instead of console to avoid interfering with proxied streams
         if (DevProxyCommand.IsStdioCommand)
         {
@@ -48,6 +53,14 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
             return builder;
         }
 
+        var showSkipMessages = configuration.GetValue("showSkipMessages", true);
+        var showTimestamps = configuration.GetValue("showTimestamps", true);
+
+        // Select the appropriate formatter based on logFor setting
+        var formatterName = configuredLogFor == LogFor.Machine
+            ? MachineConsoleFormatter.FormatterName
+            : ProxyConsoleFormatter.DefaultCategoryName;
+
         // For root command (proxy itself), use rich logging
         if (DevProxyCommand.IsRootCommand)
         {
@@ -60,17 +73,24 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
                 .AddFilter("DevProxy.Plugins.*", level =>
                     level >= configuredLogLevel &&
                     !DevProxyCommand.HasGlobalOptions)
-                .AddConsole(options =>
+                .AddConsole(consoleOptions =>
                     {
-                        options.FormatterName = ProxyConsoleFormatter.DefaultCategoryName;
-                        options.LogToStandardErrorThreshold = LogLevel.Warning;
+                        consoleOptions.FormatterName = formatterName;
+                        consoleOptions.LogToStandardErrorThreshold = LogLevel.Warning;
                     }
                 )
-                .AddConsoleFormatter<ProxyConsoleFormatter, ProxyConsoleFormatterOptions>(options =>
+                .AddConsoleFormatter<ProxyConsoleFormatter, ProxyConsoleFormatterOptions>(formatterOptions =>
                     {
-                        options.IncludeScopes = true;
-                        options.ShowSkipMessages = configuration.GetValue("showSkipMessages", true);
-                        options.ShowTimestamps = configuration.GetValue("showTimestamps", true);
+                        formatterOptions.IncludeScopes = true;
+                        formatterOptions.ShowSkipMessages = showSkipMessages;
+                        formatterOptions.ShowTimestamps = showTimestamps;
+                    }
+                )
+                .AddConsoleFormatter<MachineConsoleFormatter, ProxyConsoleFormatterOptions>(formatterOptions =>
+                    {
+                        formatterOptions.IncludeScopes = true;
+                        formatterOptions.ShowSkipMessages = showSkipMessages;
+                        formatterOptions.ShowTimestamps = showTimestamps;
                     }
                 )
                 .AddRequestLogger()
@@ -86,17 +106,24 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
             .AddFilter("Microsoft.Extensions.*", LogLevel.Error)
             .AddFilter("System.*", LogLevel.Error)
             .AddFilter("DevProxy.Plugins.*", LogLevel.None)
-            .AddConsole(options =>
+            .AddConsole(consoleOptions =>
+                {
+                    consoleOptions.FormatterName = formatterName;
+                    consoleOptions.LogToStandardErrorThreshold = LogLevel.Warning;
+                }
+            )
+            .AddConsoleFormatter<ProxyConsoleFormatter, ProxyConsoleFormatterOptions>(formatterOptions =>
                 {
-                    options.FormatterName = ProxyConsoleFormatter.DefaultCategoryName;
-                    options.LogToStandardErrorThreshold = LogLevel.Warning;
+                    formatterOptions.IncludeScopes = true;
+                    formatterOptions.ShowSkipMessages = showSkipMessages;
+                    formatterOptions.ShowTimestamps = showTimestamps;
                 }
             )
-            .AddConsoleFormatter<ProxyConsoleFormatter, ProxyConsoleFormatterOptions>(options =>
+            .AddConsoleFormatter<MachineConsoleFormatter, ProxyConsoleFormatterOptions>(formatterOptions =>
                 {
-                    options.IncludeScopes = true;
-                    options.ShowSkipMessages = configuration.GetValue("showSkipMessages", true);
-                    options.ShowTimestamps = configuration.GetValue("showTimestamps", true);
+                    formatterOptions.IncludeScopes = true;
+                    formatterOptions.ShowSkipMessages = showSkipMessages;
+                    formatterOptions.ShowTimestamps = showTimestamps;
                 }
             )
             .SetMinimumLevel(configuredLogLevel);
diff --git a/DevProxy/Logging/MachineConsoleFormatter.cs b/DevProxy/Logging/MachineConsoleFormatter.cs
new file mode 100644
index 00000000..ea36cc9a
--- /dev/null
+++ b/DevProxy/Logging/MachineConsoleFormatter.cs
@@ -0,0 +1,193 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using DevProxy.Abstractions.Proxy;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Logging.Console;
+using Microsoft.Extensions.Options;
+using System.Globalization;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace DevProxy.Logging;
+
+sealed class MachineConsoleFormatter : ConsoleFormatter
+{
+    public const string FormatterName = "devproxy-machine";
+
+    private static readonly JsonSerializerOptions _jsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
+    };
+
+    // Mapping from MessageType to semantic type strings for machine output
+    private static readonly Dictionary<MessageType, string> _messageTypeStrings = new()
+    {
+        [MessageType.InterceptedRequest] = "request",
+        [MessageType.InterceptedResponse] = "response",
+        [MessageType.PassedThrough] = "passthrough",
+        [MessageType.Chaos] = "chaos",
+        [MessageType.Warning] = "warning",
+        [MessageType.Mocked] = "mock",
+        [MessageType.Failed] = "error",
+        [MessageType.Tip] = "tip",
+        [MessageType.Skipped] = "skip",
+        [MessageType.Processed] = "processed",
+        [MessageType.Timestamp] = "timestamp",
+        [MessageType.FinishedProcessingRequest] = "finished",
+        [MessageType.Normal] = "info"
+    };
+
+    // Mapping from LogLevel to semantic level strings for machine output
+    private static readonly Dictionary<LogLevel, string> _logLevelStrings = new()
+    {
+        [LogLevel.Trace] = "trace",
+        [LogLevel.Debug] = "debug",
+        [LogLevel.Information] = "info",
+        [LogLevel.Warning] = "warning",
+        [LogLevel.Error] = "error",
+        [LogLevel.Critical] = "critical"
+    };
+
+    private readonly ProxyConsoleFormatterOptions _options;
+    private readonly HashSet<MessageType> _filteredMessageTypes;
+
+    public MachineConsoleFormatter(IOptions<ProxyConsoleFormatterOptions> options) : base(FormatterName)
+    {
+        Console.OutputEncoding = Encoding.UTF8;
+        _options = options.Value;
+
+        _filteredMessageTypes = [MessageType.InterceptedResponse, MessageType.FinishedProcessingRequest];
+        if (!_options.ShowSkipMessages)
+        {
+            _ = _filteredMessageTypes.Add(MessageType.Skipped);
+        }
+        if (!_options.ShowTimestamps)
+        {
+            _ = _filteredMessageTypes.Add(MessageType.Timestamp);
+        }
+    }
+
+    public override void Write<TState>(in LogEntry<TState> logEntry, IExternalScopeProvider? scopeProvider, TextWriter textWriter)
+    {
+        if (logEntry.State is RequestLog requestLog)
+        {
+            WriteRequestLog(requestLog, logEntry.Category, scopeProvider, textWriter);
+        }
+        else
+        {
+            WriteRegularLogMessage(logEntry, scopeProvider, textWriter);
+        }
+    }
+
+    private void WriteRequestLog(RequestLog requestLog, string category, IExternalScopeProvider? scopeProvider, TextWriter textWriter)
+    {
+        var messageType = requestLog.MessageType;
+
+        if (_filteredMessageTypes.Contains(messageType))
+        {
+            return;
+        }
+
+        var requestId = GetRequestIdScope(scopeProvider);
+        var pluginName = category == ProxyConsoleFormatter.DefaultCategoryName ? null : category;
+
+        // Extract short plugin name from full category
+        if (pluginName is not null)
+        {
+            pluginName = pluginName[(pluginName.LastIndexOf('.') + 1)..];
+        }
+
+        var logObject = new MachineRequestLogEntry
+        {
+            Type = GetMessageTypeString(messageType),
+            Message = requestLog.Message,
+            Method = requestLog.Method,
+            Url = requestLog.Url,
+            Plugin = pluginName,
+            RequestId = requestId?.ToString(CultureInfo.InvariantCulture),
+            Timestamp = DateTime.UtcNow.ToString("O", CultureInfo.InvariantCulture)
+        };
+
+        var json = JsonSerializer.Serialize(logObject, _jsonOptions);
+        textWriter.WriteLine(json);
+    }
+
+    private static void WriteRegularLogMessage<TState>(in LogEntry<TState> logEntry, IExternalScopeProvider? scopeProvider, TextWriter textWriter)
+    {
+        var message = logEntry.Formatter(logEntry.State, logEntry.Exception);
+        if (string.IsNullOrEmpty(message))
+        {
+            return;
+        }
+
+        var requestId = GetRequestIdScope(scopeProvider);
+        var category = logEntry.Category;
+
+        // Extract short category name
+        if (category is not null)
+        {
+            category = category[(category.LastIndexOf('.') + 1)..];
+        }
+
+        var logObject = new MachineLogEntry
+        {
+            Type = "log",
+            Level = GetLogLevelString(logEntry.LogLevel),
+            Message = message,
+            Category = category,
+            RequestId = requestId?.ToString(CultureInfo.InvariantCulture),
+            Timestamp = DateTime.UtcNow.ToString("O", CultureInfo.InvariantCulture),
+            Exception = logEntry.Exception?.ToString()
+        };
+
+        var json = JsonSerializer.Serialize(logObject, _jsonOptions);
+        textWriter.WriteLine(json);
+    }
+
+    private static string GetMessageTypeString(MessageType messageType) =>
+        _messageTypeStrings.TryGetValue(messageType, out var str) ? str : "unknown";
+
+    private static string GetLogLevelString(LogLevel logLevel) =>
+        _logLevelStrings.TryGetValue(logLevel, out var str) ? str : "unknown";
+
+    private static int? GetRequestIdScope(IExternalScopeProvider? scopeProvider)
+    {
+        int? requestId = null;
+        scopeProvider?.ForEachScope((scope, _) =>
+        {
+            if (scope is Dictionary<string, object> dictionary &&
+                dictionary.TryGetValue(nameof(requestId), out var req))
+            {
+                requestId = (int)req;
+            }
+        }, "");
+        return requestId;
+    }
+
+    // JSON serialization models for machine output
+    private sealed class MachineRequestLogEntry
+    {
+        public string? Type { get; set; }
+        public string? Message { get; set; }
+        public string? Method { get; set; }
+        public string? Url { get; set; }
+        public string? Plugin { get; set; }
+        public string? RequestId { get; set; }
+        public string? Timestamp { get; set; }
+    }
+
+    private sealed class MachineLogEntry
+    {
+        public string? Type { get; set; }
+        public string? Level { get; set; }
+        public string? Message { get; set; }
+        public string? Category { get; set; }
+        public string? RequestId { get; set; }
+        public string? Timestamp { get; set; }
+        public string? Exception { get; set; }
+    }
+}
diff --git a/DevProxy/Proxy/ProxyConfiguration.cs b/DevProxy/Proxy/ProxyConfiguration.cs
index d22b58da..381fcc83 100755
--- a/DevProxy/Proxy/ProxyConfiguration.cs
+++ b/DevProxy/Proxy/ProxyConfiguration.cs
@@ -34,6 +34,8 @@ public string ConfigFile
     public string? IPAddress { get; set; } = "127.0.0.1";
     public bool InstallCert { get; set; } = true;
     [JsonConverter(typeof(JsonStringEnumConverter))]
+    public LogFor LogFor { get; set; } = LogFor.Human;
+    [JsonConverter(typeof(JsonStringEnumConverter))]
     public LogLevel LogLevel { get; set; } = LogLevel.Information;
     public bool NoFirstRun { get; set; }
     [JsonConverter(typeof(JsonStringEnumConverter))]
diff --git a/DevProxy/Proxy/ProxyEngine.cs b/DevProxy/Proxy/ProxyEngine.cs
index bba35c90..599800f1 100755
--- a/DevProxy/Proxy/ProxyEngine.cs
+++ b/DevProxy/Proxy/ProxyEngine.cs
@@ -139,7 +139,7 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         var isInteractive = !Console.IsInputRedirected &&
             Environment.GetEnvironmentVariable("CI") is null;
 
-        if (isInteractive)
+        if (isInteractive && _config.LogFor != LogFor.Machine)
         {
             // only print hotkeys when they can be used
             PrintHotkeys();
@@ -217,7 +217,10 @@ private async Task ReadKeysAsync(CancellationToken cancellationToken)
                 break;
             case ConsoleKey.C:
                 Console.Clear();
-                PrintHotkeys();
+                if (_config.LogFor != LogFor.Machine)
+                {
+                    PrintHotkeys();
+                }
                 break;
             case ConsoleKey.W:
                 await _proxyController.MockRequestAsync(cancellationToken);
diff --git a/schemas/v2.1.0/rc.schema.json b/schemas/v2.1.0/rc.schema.json
index 369a19a0..e67f092a 100644
--- a/schemas/v2.1.0/rc.schema.json
+++ b/schemas/v2.1.0/rc.schema.json
@@ -85,6 +85,14 @@
       ],
       "description": "The minimum log level for Dev Proxy output."
     },
+    "logFor": {
+      "type": "string",
+      "enum": [
+        "human",
+        "machine"
+      ],
+      "description": "Target audience for log output. Use 'human' for readable console output (default), or 'machine' for structured JSON Lines output suitable for LLMs and agents."
+    },
     "newVersionNotification": {
       "type": "string",
       "enum": [