What is SignalR?

What is SignalR?

SignalR is an open-source, real-time messaging framework developed by Microsoft that allows developers to build interactive and dynamic applications, such as chat and messaging, that instantly push data from the server to the client.

SignalR enables bi-directional communication between the server and clients, allowing for real-time data transfer and instant updates without continuous polling or refreshing the web page.

What is SignalR used for?

The key purpose of SignalR is to provide a seamless and efficient way for developers to build real-time functionality, such as chat applications, real-time collaboration tools, real-time dashboards, and more. It eliminates the need for developers to write complex and custom code to handle real-time communication, as SignalR handles the underlying plumbing and provides the necessary API.

Is SignalR obsolete?

No, SignalR is still widely used and supported by Microsoft, and it has been continuously updated and improved over the years.  SignalR has been integrated into ASP.NET Core and remains a popular choice amongst developers.

What is the cost of SignalR?

SignalR is released under an Apache licenseopen-source and free to use, without any licensing fees or costs.

What are the features of SignalR?

SignalR is a powerful framework that enables real-time communication for web development projects. Here are some of the key features of SignalR:

  • Real-time communication: SignalR allows instant, bi-directional communication between the server and the client. Depending on the client's capabilities, it uses WebSockets, Server-Sent Events (SSE), or Long Polling and falls back to a lower transport mechanism if necessary.

  • Scalability: SignalR offers built-in support for scaling out across multiple servers and can seamlessly handle many concurrent connections. It supports various backplane implementations like SQL Server, Redis, and Azure Service Bus to distribute messages across multiple instances.

  • Cross-platform compatibility: SignalR supports multiple platforms and can use various programming languages, including .NET (NET 6 and NET 7), .NET Core, and JavaScript. It allows for client communication, such as web browsers, mobile devices, and desktop applications.

  • Persistent connections: SignalR maintains a persistent connection between the client and the server, enabling real-time updates without constant polling. This results in reduced network overhead and improved performance.

  • Automatic reconnection: SignalR provides automatic reconnection capabilities, allowing clients to reconnect to the server in case of network interruptions or server restarts. This ensures a seamless user experience even in unstable network conditions.

  • Hub-based architecture: SignalR follows a hub-based architecture, where a central hub manages all the communication between clients and servers. Clients can call methods on the hub, and the hub can also invoke methods on connected clients. This simplifies the development process and allows for easy communication between specific sets of clients.

  • Authentication and authorization: SignalR supports authentication and authorization mechanisms, allowing developers to secure their chat and messaging applications. It integrates with ASP.NET Identity and other authentication providers, enabling authentication at the connection or individual method levels.

  • Message broadcasting: SignalR allows developers to easily broadcast messages to multiple clients or specific groups of clients. This is useful for scenarios like chat rooms or push notifications.

  • Customizable error handling: SignalR provides flexibility in handling errors that occur during communication. Developers can customize error handling and implement appropriate error logging or recovery mechanisms.

  • Extensibility: SignalR is highly extensible and allows developers to customize and extend its functionality. It provides hooks for customizing connection management, message serialization, and other aspects of the communication process.

SignalR limitations

While SignalR offers many benefits for developers building chat and messaging applications, it also has a few disadvantages worth considering:

  • Complexity: While SignalR simplifies the building of real-time applications, it can still be complex to set up and configure. It requires understanding the underlying communication protocols and may involve configuring server infrastructure to support real-time communication.

  • Performance: Although SignalR is designed to handle high traffic and scale easily, it may not be as performant as other real-time communication libraries or frameworks. The choice of communication techniques, such as WebSockets, Server-Sent Events, or long polling, can impact the application's performance.

  • Learning Curve: For developers new to real-time communication or the SignalR library, there may be a learning curve involved in understanding its concepts, APIs, and best practices. This can slow down the development process and require additional resources for training or documentation.

  • Infrastructure management: SignalR requires developers to manage their infrastructure, including servers and network resources. This can be time-consuming and costly, involving monitoring and maintaining server health, ensuring sufficient bandwidth for message delivery, and handling potential scaling needs.

  • Platform limitations: SignalR is primarily designed for use with .NET applications, which can limit its compatibility with other platforms and frameworks. While libraries and plugins are available for other languages, the level of support and functionality may vary.

  • Security considerations: SignalR provides some basic security features, such as authentication and authorization, but it may not meet the specific security requirements of every application. Developers should consider their security needs carefully and ensure that SignalR can adequately address them.

What platforms are supported by SignalR?

SignalR supports a wide range of platforms, making it a versatile choice for developers. Here are the platforms that SignalR supports:

  • .NET Framework: SignalR was initially built for the .NET Framework, making it a natural choice for developers using this platform. It provides a seamless integration with ASP.NET and allows developers to build real-time web applications easily.

  • .NET Core: With the introduction of .NET Core, Microsoft made SignalR available for cross-platform development. SignalR for .NET Core allows developers to build real-time applications running on Windows, Linux, and macOS.

  • Xamarin: SignalR also supports Xamarin, a popular cross-platform framework for building mobile applications. With SignalR, developers can add real-time functionality to their Xamarin apps and provide a rich messaging experience to their users.

  • JavaScript: SignalR provides a JavaScript client library that enables developers to use SignalR in web applications built with JavaScript frameworks like Angular, React, or Vue.js. This allows developers to create real-time web applications not tied to any specific backend technology.

  • Java: Besides Microsoft's platforms, SignalR also supports Java. Developers can use the SignalR Java client library to add real-time functionality to their Java applications, providing a great messaging experience for their users.

It's important to note that while SignalR supports a wide range of platforms, it is primarily associated with the .NET ecosystem. This means developers who prefer other programming languages or frameworks may need to rely on third-party libraries or alternative solutions for real-time communication.

What protocols does SignalR support?

SignalR supports multiple protocols to enable real-time communication between clients and servers. Here are the protocols supported by SignalR:

  • WebSockets: SignalR uses WebSockets as the primary transport protocol whenever available in the client and server. WebSockets provide a full-duplex communication channel between the client and server, allowing both parties to send and receive data in real time.

  • Server-Sent Events (SSE): When WebSockets are unavailable or supported, SignalR returns to using SSE. SSE is a unidirectional communication protocol where the server sends events to the client over a long-lived HTTP connection. This allows the server to push real-time updates to the client without requiring frequent polling.

  • Long Polling: If neither WebSockets nor SSE are available, SignalR can use long polling as a fallback option. Long polling involves the client sending a request to the server and keeping the connection open until the server has new data to send. Once the server responds, the client immediately sends another request to maintain the connection.

SignalR Architecture

The architecture of SignalR is based on a client-server model and follows a hub-and-spoke pattern. It consists of the following components:

  1. Client: The client is responsible for connecting to the SignalR server and sending/receiving messages. It can be a web browser, a mobile app, or any other client application that supports the SignalR protocol.

  2. Server: The SignalR server manages connections, routes messages between clients, and handles client connection/disconnection events. It acts as a central hub for all real-time communication.

  3. Hubs: Hubs are the main communication channels in SignalR. They abstract the underlying transport layer (such as WebSockets or long polling) and provide a high-level API for clients to send/receive messages. Hubs can be thought of as remote procedure call (RPC) endpoints that clients can invoke, and they can also broadcast messages to multiple clients.

  4. Transports: SignalR supports multiple transport protocols, including WebSockets, Server-Sent Events (SSE), and long polling. Transports are responsible for establishing and maintaining the connection between the client and server. The choice of transport depends on the capabilities of the client and server and is negotiated during the initial connection.

  5. Connection: A connection represents a persistent communication channel between a client and the server. It allows the server to send messages to specific clients or broadcast messages to multiple clients. Each client is assigned a unique connection ID during the initial connection, which is used to identify the client in subsequent communication.

Streaming in SignalR

Streaming in SignalR is a feature that allows developers to send a continuous stream of data from the server to the clients in realtime. This is useful in scenarios where clients must receive updates or notifications as soon as they become available.

SignalR provides two types of streaming: server-to-client streaming and client-to-server streaming.

Server-to-client streaming allows the server to send a continuous data stream to multiple clients simultaneously. This can be useful for real-time dashboards, live chat, or stock market updates. SignalR handles the management of the connections and ensures that the data is delivered efficiently to all connected clients.

To implement server-to-client streaming in SignalR, developers can use the Stream class provided by SignalR. They can write data to the stream, and SignalR sends it to the connected clients.

Alternatively, Client-to-server streaming allows clients to send a continuous data stream to the server. This can be useful in scenarios where clients must upload a large amount of data, like file uploads or real-time media streaming.

To implement client-to-server streaming in SignalR, developers can use the Stream class on the client side to send the data stream to the server. On the server side, they can use the OnReceived event handler to process the incoming data stream.

SignalR Use Cases

SignalR is a versatile technology used in various applications requiring real-time capabilities. Here are some common use cases where SignalR can be particularly beneficial:

  1. Multi-user collaboration: SignalR is ideal for applications that require real-time collaboration, such as collaborative document editing, project management tools, or shared whiteboards. With SignalR, multiple users can simultaneously edit or view content and see the changes reflected in realtime.

  2. Live chat and messaging: SignalR can be used to build chat applications, allowing users to send and receive messages instantly. This can be useful for customer support systems, team communication platforms, or social networking applications.

  3. Mobile push notifications: SignalR can push real-time notifications to users, informing them about important events or updates. This can be useful for applications that require instant updates, such as stock trading platforms, news applications, or sports scoreboards.

  4. Multiplayer games: SignalR's realtime capabilities make it a great choice for building multiplayer games. Users can interact with each other in real time, making the gaming experience more immersive and engaging.

  5. IoT device control: SignalR can be used in Internet of Things (IoT) applications to enable real-time communication between devices and the cloud. This can be useful for home automation systems, smart city solutions, or industrial monitoring and control applications.

How can I start using SignalR?

To start using SignalR, you need to follow a few steps:

1. Install SignalR: SignalR is available as a NuGet package for .NET applications, so you must install it using the NuGet Package Manager. Open the Package Manager Console in Visual Studio and run the following command:


Install-Package Microsoft.AspNet.SignalR


2. Set up a SignalR hub: A hub is a class that inherits from the Hub class provided by SignalR. It acts as a communication endpoint for clients and handles the real-time messaging. Create a new class that inherits from Hub and define the methods that will be called by clients. For example:


using Microsoft.AspNet.SignalR;

public class ChatHub : Hub


public void SendMessage(string user, string message)


Clients.All.broadcastMessage(user, message);




3. Configure SignalR in your application: In your application's startup code (e.g., Startup.cs for ASP.NET Core), you need to configure SignalR by adding it to the middleware pipeline. For example, in an ASP.NET Core application, you can add SignalR using the following code:


using Microsoft.AspNetCore.Builder;

using Microsoft.Extensions.DependencyInjection;

public class Startup


public void ConfigureServices(IServiceCollection services)


// Other service configurations



public void Configure(IApplicationBuilder app)


// Other app configurations


app.UseEndpoints(endpoints =>







4. Connect to SignalR from clients: Clients can connect to SignalR using a SignalR client library. SignalR provides client libraries for various platforms, including JavaScript, .NET, Xamarin, and more. Clients can connect to SignalR using the hub URL specified in the previous step. For example, in a JavaScript client, you can connect to SignalR using the following code:


var connection = new signalR.HubConnectionBuilder().withUrl("/chathub").build();

connection.start().then(function () {

console.log("Connected to SignalR");

}).catch(function (err) {




Is SignalR secure?

SignalR provides security features to help protect applications. One of the key security features is encrypted data transmission, which ensures that messages are sent over secure channels. This helps prevent eavesdropping and unauthorized access to the data being transmitted.

In addition, SignalR allows developers to implement authentication and authorization mechanisms. This means that users can be required to authenticate themselves before accessing the application, and their access can be restricted based on their roles and permissions. This helps prevent unauthorized access to the application and protects sensitive information.

SignalR also includes built-in protection against common security threats like cross-site scripting (XSS) and SQL injection. It automatically sanitizes user input to prevent malicious code execution and SQL injection attacks. This helps protect the application from such vulnerabilities and ensures data security.

However, developers must implement these security measures properly and follow best practices. This includes properly configuring encryption settings, implementing secure authentication mechanisms, and validating and sanitizing user input. It is also important to regularly update SignalR and keep up with security patches and updates to ensure the application's security.

What is SignalR service mode?

SignalR service mode refers to the deployment options available for hosting SignalR applications. There are two main modes for hosting SignalR: Self-hosting and Azure SignalR Service.

Self-hosting: In self-hosting mode, developers have full control over hosting their SignalR application and can choose to host it in their infrastructure, such as on-premises servers or virtual machines, or in a cloud environment like Amazon Web Services (AWS) or Google Cloud Platform (GCP). Self-hosting allows developers to manage and configure the hosting environment according to their specific requirements.

Azure SignalR Service: Azure SignalR Service is a fully managed service provided by Microsoft Azure. It abstracts away the complexities of hosting and scaling SignalR applications, allowing developers to focus on building their application logic. With Azure SignalR Service, developers can easily scale their applications to handle high traffic loads and ensure high availability. It also provides features like automatic message routing, built-in authentication, and serverless SignalR functions.

When deciding between self-hosting and Azure SignalR Service, developers should consider scalability requirements, deployment complexity, and operational overhead. Self-hosting may be suitable for smaller applications or developers who prefer more control over the hosting environment. On the other hand, Azure SignalR Service is a convenient option for larger applications or developers who want to offload the hosting and scaling responsibilities to a managed service.

MQTT vs SignalR

MQTT and SignalR are both technologies used for communication between devices and servers, but they service different purposes and have different features.

What is the difference between MQTT and SignalR?

MQTT is a lightweight messaging protocol using publish and subscribe for communication between devices in IoT applications whereas SignalR is a web application framework that provides real-time communication between clients and servers using a variety of transport protocols including websockets, and HTTP long-polling.

MQTT is designed to work with low-power, low-bandwidth devices primarily in the IoT space whereas SignalR is designed for web applications.

SignalR vs. WebSockets

When it comes to building real-time chat and messaging applications, developers often face the decision of choosing between SignalR and WebSockets. Both technologies have strengths and weaknesses, and understanding their differences is crucial for making an informed decision.

In this article, we will compare SignalR and WebSockets regarding scalability and security to help you choose the right platform for your application.

Is SignalR better than Websockets?


SignalR is a high-level library built on WebSockets that abstracts away the complexities of managing connections and message routing. It provides features like automatic reconnection, message broadcasting, and hub-based communication. SignalR is designed to scale horizontally, making it easy to handle many concurrent clients.

WebSockets is a low-level protocol that provides a full-duplex communication channel between the client and the server. It allows real-time, bi-directional communication, enabling instant updates and push notifications. However, unlike SignalR, WebSockets does not provide built-in features for scaling, and developers have to handle connection management and load balancing themselves.


SignalR incorporates multiple security features, including support for Transport Layer Security (TLS) encryption, cross-origin resource sharing (CORS), and the ability to authenticate and authorize users. It also provides options for implementing additional security measures, such as using tokens for authentication or integrating with existing authentication systems.

WebSockets, by itself, does not provide any built-in security features. However, it can be a building block for implementing secure communication channels. Developers can use techniques like TLS encryption, authentication, and authorization to secure WebSocket connections. It is important to note that the responsibility of implementing security measures lies with the developers when using WebSockets.

SignalR and WebSockets have strengths and weaknesses in building real-time chat and messaging applications. SignalR provides a higher level of abstraction and built-in features for scalability and security, making it easier for developers to handle these aspects. On the other hand, WebSockets offer more control and flexibility but require developers to manage scalability and security themselves. Ultimately, the choice between SignalR and WebSockets depends on the specific requirements and preferences of the application being developed.

SignalR Alternatives

PubNub and SignalR are popular platforms for building real-time chat and messaging applications. While they have some similarities, there are also key differences that developers should consider when choosing between them.

One of the main differences between PubNub and SignalR is their architecture. PubNub is a cloud-based platform that provides a global network of data centers to ensure low-latency communication. It uses a publish-subscribe model, where messages are published to channels, and subscribers receive them in realtime. This architecture makes PubNub highly scalable and capable of handling large volumes of messages and concurrent users without financially penalizing you.

SignalR is a library that developers can use in their applications. It can be integrated into server-side frameworks like ASP.NET or used with other platforms via its client libraries. SignalR uses various techniques to provide real-time communication, including WebSockets, Server-Sent Events, and long polling. This gives developers control over the implementation and customization of their real-time applications.

In terms of security, both PubNub and SignalR offer features to ensure the secure transmission of messages. PubNub provides encrypted data transmission by default, using SSL/TLS to encrypt the communication between clients and the PubNub network. SignalR also supports ensuring messages are sent over secure channels.

When it comes to authentication and authorization mechanisms, both PubNub and SignalR have options for securing access to applications. PubNub supports various authentication methods, including access tokens, user authentication, and IP filtering. It also offers authorization features like channel-level permissions and message-level encryption. SignalR, on the other hand, allows developers to implement their authentication mechanisms using ASP.NET authentication providers or custom authentication middleware.

Another important aspect to consider is the ease of use and developer experience. PubNub provides a comprehensive set of APIs and SDKs and is programming language-agnostic, making it easier for developers to integrate real-time functionality into their applications. It also offers features like presence detection, message persistence, and mobile push notifications. SignalR, being a library, requires developers to understand the underlying technology and may require more effort to implement and customize.

Lastly, pricing is an important consideration for developers. PubNub offers different pricing plans based on the number of messages and concurrent users, with a free tier available for low-volume applications. SignalR, being a library, does not have a pricing model, but developers may incur costs for hosting and infrastructure depending on their use case.

Is PubNub a better alternative to SignalR?

PubNub provides developers with a scalable, secure, and feature-rich platform for building real-time applications. By leveraging our infrastructure, SDKs, and extensive library of tutorials, developers can focus on creating innovative and engaging user experiences. At the same time, PubNub takes care of the underlying complexities of real-time communication so you can focus on building sticky apps that engage users.

Check out our Github or sign up for a free trial where you’ll get up to 200 MAUs or 1M total transactions per month for free.