This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

OWIN allows web apps to be decoupled from web servers. It defines a standard way for middleware to be used in a pipeline to handle requests and associated responses. ASP.NET Core applications and middleware can interoperate with OWIN-based applications, servers, and middleware.

OWIN provides a decoupling layer that allows two frameworks with disparate object models to be used together. The Microsoft.AspNetCore.Owin package provides two adapter implementations:

This allows ASP.NET Core to be hosted on top of an OWIN compatible server/host or for other OWIN compatible components to be run on top of ASP.NET Core.

Using these adapters comes with a performance cost. Apps using only ASP.NET Core components shouldn't use the Microsoft.AspNetCore.Owin package or adapters.

View or download sample code ( how to download )

Running OWIN middleware in the ASP.NET Core pipeline

ASP.NET Core's OWIN support is deployed as part of the Microsoft.AspNetCore.Owin package. You can import OWIN support into your project by installing this package.

OWIN middleware conforms to the OWIN specification , which requires a Func<IDictionary<string, object>, Task> interface, and specific keys be set (such as owin.ResponseBody ). The following simple OWIN middleware displays "Hello World":

public Task OwinHello(IDictionary<string, object> environment)
    string responseText = "Hello World via OWIN";
    byte[] responseBytes = Encoding.UTF8.GetBytes(responseText);
    // OWIN Environment Keys: https://owin.org/spec/spec/owin-1.0.0.html
    var responseStream = (Stream)environment["owin.ResponseBody"];
    var responseHeaders = (IDictionary<string, string[]>)environment["owin.ResponseHeaders"];
    responseHeaders["Content-Length"] = new string[] { responseBytes.Length.ToString(CultureInfo.InvariantCulture) };
    responseHeaders["Content-Type"] = new string[] { "text/plain" };
    return responseStream.WriteAsync(responseBytes, 0, responseBytes.Length);
The sample signature returns a Task and accepts an IDictionary<string, object> as required by OWIN.
The following code shows how to add the OwinHello middleware (shown above) to the ASP.NET Core pipeline with the UseOwin extension method.
public void Configure(IApplicationBuilder app)
    app.UseOwin(pipeline =>
        pipeline(next => OwinHello);
You can configure other actions to take place within the OWIN pipeline.
Response headers should only be modified prior to the first write to the response stream.
Multiple calls to UseOwin is discouraged for performance reasons. OWIN components will operate best if grouped together.
app.UseOwin(pipeline =>
    pipeline(next =>
        return async environment =>
            // Do something before.
            await next(environment);
            // Do something after.
Run ASP.NET Core on an OWIN-based server and use its WebSockets support
Another example of how OWIN-based servers' features can be leveraged by ASP.NET Core is access to features like WebSockets. The .NET OWIN web server used in the previous example has support for Web Sockets built in, which can be leveraged by an ASP.NET Core application. The example below shows a simple web app that supports Web Sockets and echoes back everything sent to the server through WebSockets.
public class Startup
    public void Configure(IApplicationBuilder app)
        app.Use(async (context, next) =>
            if (context.WebSockets.IsWebSocketRequest)
                WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();
                await EchoWebSocket(webSocket);
                await next();
        app.Run(context =>
            return context.Response.WriteAsync("Hello World");
    private async Task EchoWebSocket(WebSocket webSocket)
        byte[] buffer = new byte[1024];
        WebSocketReceiveResult received = await webSocket.ReceiveAsync(
            new ArraySegment<byte>(buffer), CancellationToken.None);
        while (!webSocket.CloseStatus.HasValue)
            // Echo anything we receive
            await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, received.Count), 
                received.MessageType, received.EndOfMessage, CancellationToken.None);
            received = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), 
                CancellationToken.None);
        await webSocket.CloseAsync(webSocket.CloseStatus.Value, 
            webSocket.CloseStatusDescription, CancellationToken.None);
OWIN environment
You can construct an OWIN environment using the HttpContext.
   var environment = new OwinEnvironment(HttpContext);
   var features = new OwinFeatureCollection(environment);
OWIN keys
OWIN depends on an IDictionary<string,object> object to communicate information throughout an HTTP Request/Response exchange. ASP.NET Core implements the keys listed below. See the primary specification, extensions, and OWIN Key Guidelines and Common Keys.
Request data (OWIN v1.0.0)
Value (type)
Description
Additional resources
See the source on GitHub for OWIN keys supported in the translation layer.
Middleware
Servers
			Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see: https://aka.ms/ContentUserFeedback.

        
Submit and view feedback for
                    This product