System.Text.Json vs Newtonsoft.Json for LLM responses

Parsing LLM output in C# forces a choice that shapes your entire integration layer. The debate around system.text.json vs newtonsoft.json llm response handling isn’t academic—it determines how you deal with streaming deltas, polymorphic tool calls, and provider-specific extensions that rarely match your idealized data model. Most teams inherit a default from their project template and never revisit it. When the payload is non-deterministic text from a language model, that default can become a liability.

Capabilities

System.Text.Json (STJ) ships inside the .NET runtime. It provides UTF-8 native parsing through Utf8JsonReader, source-generated serializers, and strict RFC 8259 compliance. For a chat completion, you bind directly to a record and the reader throws on the first malformed token.

public record ChatCompletion(
    string Id,
    string Object,
    long Created,
    string Model,
    List<Choice> Choices);

public record Choice(int Index, Message Message, string FinishReason);

public record Message(string Role, string Content, List<ToolCall>? ToolCalls = null);

Newtonsoft.Json (Json.NET) builds a mutable JObject graph and exposes dynamic. It tolerates comments, trailing commas, and ambiguous date strings—artifacts you will see when a model echoes JSON from a blog post it memorized.

var raw = JObject.Parse(responseBody);
var content = (string)raw["choices"]?[0]?["message"]?["content"];

Polymorphic tool calls

LLM function calling introduces sibling shapes under one field. STJ requires explicit discrimination:

[JsonDerivedType("function", typeof(FunctionCall))]
public abstract record ToolCall(string Id, string Type);

public record FunctionCall(string Id, string Type, string Name, JsonElement Arguments)
    : ToolCall(Id, Type);

Newtonsoft handles this with JToken inspection or the legacy $type convention, no recompilation needed when a new tool type appears.

The system.text.json vs newtonsoft.json llm polymorphism gap narrows if you use a custom JsonConverter, but that is code you maintain.

Price and Cost Model

Neither library charges a license fee; both are MIT-licensed. The real cost is operational. STJ’s low-allocation reader reduces GC pauses, which can let a single pod handle more concurrent streams before autoscaling. Newtonsoft’s DOM approach increases working set per request; at scale you pay for extra memory or nodes. For a side-project calling an LLM occasionally, the difference is invisible. For a gateway processing millions of completions daily, STJ’s efficiency is a direct line item on your cloud bill.

Latency and Throughput

STJ deserializes from ReadOnlySpan<byte> without creating intermediate strings. With source generation enabled, it avoids reflection entirely.

var options = new JsonSerializerOptions
{
    TypeInfoResolver = ChatCompletionContext.Default
};
await using var stream = await httpClient.GetStreamAsync(url);
var completion = await JsonSerializer.DeserializeAsync<ChatCompletion>(stream, options);

Newtonsoft’s JsonTextReader is asynchronous but still constructs JToken nodes. It is fast enough for most CRUD-style LLM features, but benchmarks from the .NET team show multi-fold gaps on large documents.

When you proxy through an OpenAI-compatible gateway such as n4n.ai that automatically falls back across providers, the network hop dominates. Your serializer choice matters only on the edges—parse once, cache the typed object, and reuse it.

Ergonomics

STJ’s attribute surface is small: [JsonPropertyName], [JsonIgnore], [JsonRequired]. Constructor binding works when names align. Naming policies (JsonNamingPolicy.CamelCase) handle the snake_case some providers emit.

Newtonsoft wins on forgiveness. MissingMemberHandling.Ignore and NullValueHandling.Ignore let you evolve DTOs without breaking on provider additions.

var settings = new JsonSerializerSettings
{
    NullValueHandling = NullValueHandling.Ignore,
    MissingMemberHandling = MissingMemberHandling.Ignore,
    ContractResolver = new CamelCasePropertyNamesContractResolver()
};

If you prototype against a model that returns unpredictable keys, JObject beats writing a new record every hour.

Ecosystem

STJ is the default in ASP.NET Core and the Azure SDK. Incoming webhook bodies from LLM event sources are already parsed by it. Newtonsoft persists in Unity, older Xamarin, and libraries like Hangfire. Its Newtonsoft.Json.Schema package remains the quickest way to validate an LLM output against a JSON Schema before you persist it.

Limits

STJ rejects duplicate keys and non-standard numbers unless you set JsonReaderOptions. That strictness catches hallucinations producing invalid JSON, but also breaks when a provider inserts a debug field mid-stream. Newtonsoft’s flexibility becomes a liability with large responses: a 50K-token verbose trace builds a heavy DOM. The system.text.json vs newtonsoft.json llm limit profile splits on trust—strict when you trust the contract, lenient when you don’t.

Head-to-Head Table

Which to Choose

Greenfield API proxy or high-throughput batch processor. Use System.Text.Json. Enable source generation for completion DTOs and let the strict reader flag malformed provider responses early.

Legacy service calling an LLM for the first time. Stick with Newtonsoft.Json if the rest of your codebase already uses it. Rewriting serializers to chase microseconds is not worth the regression risk.

Dynamic tool-calling or agent loops. Newtonsoft’s JObject reduces friction when the model emits new function schemas weekly. Parse, log, and validate without recompiling DTOs.

Strict compliance and low latency. STJ with JsonSerializerOptions.Web and DeserializeAsync gives the smallest footprint. Pair it with a gateway that honors routing directives so the response shape is predictable.

Mixed environment. Use STJ for the hot path and Newtonsoft only in a thin adapter that normalizes weird payloads. Both libraries coexist in the same assembly without conflict.

Pick based on where the pain is: schema stability or developer velocity. The JSON layer is not where you win or lose the LLM feature—but it is where you debug at 2 a.m.