--- title: Transform the response body on every page description: "Implement IResponseProcessor to rewrite the final response body as a string — inject HTML before , log an outgoing payload, or append a non-HTML footer." canonical_url: https://usepennington.net/how-to/response-pipeline/response-processor/ sidecar_url: https://usepennington.net/how-to/response-pipeline/response-processor.md content_hash: sha256:2300993212d3cebaab263fd0f786383bc1cfece03eb5451ba7de427dd2c66334 tokens: 1830 uid: how-to.response-pipeline.response-processor reading_time_minutes: 3 --- Guides # Transform the response body on every page Implement IResponseProcessor to rewrite the final response body as a string — inject HTML before , log an outgoing payload, or append a non-HTML footer. To transform the final response body on every rendered page, implement `IResponseProcessor`. The processor receives the full body as a string and returns the replacement — use it to insert a pre-serialized HTML fragment before ``, log an outgoing payload, or append a non-HTML footer. When the work is DOM-shaped (anchor rewrites, attribute additions, element injection at a CSS selector), implement `IHtmlResponseRewriter` instead so every rewriter shares one AngleSharp parse. See [Rewrite HTML attributes after parsing](https://usepennington.net/how-to/response-pipeline/html-rewriter.md). The recipe references `examples/ExtensibilityLabExample/FeedbackWidgetProcessor.cs`, which injects a "Was this helpful?" aside before `` against a bare `AddPennington` host. ## Before you begin - An existing Pennington site (see [Create your first Pennington site](https://usepennington.net/tutorials/getting-started/first-site.md) if not). - The response pipeline buffers the full response body before the processor runs. This is fine for HTML pages but unsuitable for large binary streams — gate those out in `ShouldProcess`. ## Write the processor Implement [Pennington.Infrastructure.IResponseProcessor](https://usepennington.net/reference/api/i-response-processor.md) as a sealed class. Two rules carry the page: - `ShouldProcess` runs before the body is buffered. Returning `false` skips body capture entirely, so this is where filtering by status code, content type, or request path belongs. The example accepts only 2xx HTML responses, letting static assets, JSON endpoints, and redirects pass through untouched. - `ProcessAsync` receives the full captured body as a string and returns the replacement. The example locates the last `` with `LastIndexOf` and inserts the widget HTML there, falling back to append-at-end when the tag is absent so content still reaches the browser. ```csharp:symbol namespace ExtensibilityLabExample; using System.Text; using Microsoft.AspNetCore.Http; using Pennington.Infrastructure; /// /// Implements . Injects a /// "Was this helpful?" footer before the closing </body> /// tag of every rendered HTML page. /// /// Runs at 500 — after the xref/locale/base-URL HTML /// rewriting processor (HtmlResponseRewritingProcessor) so the /// injected HTML is not subject to any further pipeline passes in this /// app, and well before the live-reload and diagnostic-overlay /// processors at 1000+. /// /// /// gates on content type: text/html only, /// and only for 2xx responses. Static assets and API JSON skip through. /// /// /// Backs how-to 2.3.40 /how-to/extensibility/response-processor. /// /// public sealed class FeedbackWidgetProcessor : IResponseProcessor { private const string WidgetHtml = """ """; public int Order => 500; public bool ShouldProcess(HttpContext context) { if (context.Response.StatusCode is < 200 or >= 300) { return false; } var contentType = context.Response.ContentType; return contentType is not null && contentType.StartsWith("text/html", StringComparison.OrdinalIgnoreCase); } public Task ProcessAsync(string responseBody, HttpContext context) { if (string.IsNullOrEmpty(responseBody)) { return Task.FromResult(responseBody); } var closeBodyIndex = responseBody.LastIndexOf("", StringComparison.OrdinalIgnoreCase); if (closeBodyIndex < 0) { // No — append at end. Still visible, still verifiable. return Task.FromResult(responseBody + WidgetHtml); } var sb = new StringBuilder(responseBody.Length + WidgetHtml.Length); sb.Append(responseBody, 0, closeBodyIndex); sb.Append(WidgetHtml); sb.Append(responseBody, closeBodyIndex, responseBody.Length - closeBodyIndex); return Task.FromResult(sb.ToString()); } } ``` ## Pick an Order value Slot into the `Order` sequence so the processor sees the HTML state it expects. Anything below `10` would see un-resolved `` placeholders that `HtmlResponseRewritingProcessor` expands. The example uses `500` so the widget is inserted after every built-in pass has run. For the full table of shipped `Order` values, see [Pennington.Infrastructure.IResponseProcessor](https://usepennington.net/reference/api/i-response-processor.md). ## Register the processor Every registered `IResponseProcessor` is picked up and ordered by its `Order` value, so a single registration is the entire wiring step. Use the lifetime that matches your dependencies — `AddSingleton` for stateless processors, `AddTransient` (or `AddFileWatched`) when the processor captures file-watched state. ```csharp builder.Services.AddSingleton(); ``` ## Result Every `text/html` response carries the widget aside immediately before its closing `` tag: ```html ``` Non-HTML endpoints (`/styles.css`, `/sitemap.xml`) are unmodified because `ShouldProcess` returns `false` for them. ## Verify - Run `dotnet run --project examples/ExtensibilityLabExample` and visit `/`. The rendered HTML contains `