Pusher vs. SignalR: feature comparison, use cases, pros and cons

Acquired by MessageBird in 2020, Pusher is a PaaS that allows developers to build realtime features and add them to web and mobile applications. Pusher provides realtime APIs, managed messaging infrastructure, and capabilities like:

• Pub/sub messaging over WebSockets (Pusher Channels).

• Push notifications (Pusher Beams).

• Presence.

• Authentication, authorization, and encryption.

• Webhooks.

What are Pusher’s key advantages and disadvantages?

Pusher pros

• Pusher primarily uses WebSockets for realtime communication, but its JavaScript library can fall back to HTTP streaming and polling in environments where WebSockets aren’t supported (for example, some corporate networks block WebSocket connections).  

• Client SDKs for every major development platform and programming language, giving you the flexibility of integrating Pusher in your preferred language.

• Due to its pub/sub APIs, Pusher supports several messaging patterns: one-to-one, one-to-many (fan-out), and many-to-many. 

Pusher cons

• Message delivery is not guaranteed; for example, if a message is published whilst a client is briefly disconnected (such as going through a tunnel or changing networks), then the message published over Pusher will never arrive to that client.

• Compared to some alternative realtime solutions, Pusher offers a limited feature set. For example, it doesn’t support message history or message delta compression. Additionally, Pusher provides no integrations with services such as event streaming platforms (e.g., Kafka), queuing systems, and serverless platforms (e.g., AWS Lambda, Azure Functions, etc.). 

• Pusher requires you to choose a single datacenter for an app to reside in. All realtime traffic must therefore be routed through that single datacenter, regardless of a user’s location. This has negative implications on performance (increased latency), reliability, and availability (single point of congestion and failure).

SignalR is a technology that enables you to add realtime functionality to web apps. SignalR comes in several different flavors - it’s available as an open-source library for ASP. NET developers (ASP .NET Core SignalR), but also as a fully managed service (Azure SignalR Service). 

SignalR uses WebSocket as the main underlying transport, while providing additional features, such as:

• Automatic reconnections.

• Alternative transports (long polling and Server-Sent Events). 

• The ability to send messages to all connected clients simultaneously, or to specific (groups of) clients.

• Hubs. A SignalR Hub is a high-level pipeline that enables connected servers and clients to invoke methods on each other.   

What are the key advantages and disadvantages of SignalR? 

SignalR pros

• SignalR uses efficient message serialization techniques (e.g., MessagePack) to reduce the amount of bandwidth required for realtime communication. This is particularly important for mobile devices and other low-bandwidth networks.

• Part of the ASP. NET Framework, which makes it easy to use SignalR in combination with other ASP.NET features like authentication, authorization, and dependency injection. 

• SignalR is flexible: it supports three transport protocols, and you can use it for 1:1 and 1:many messaging, as well as for client-to-server and server-to-client streaming. 

SignalR cons

• SignalR offers rather weak messaging QoS; ordering and delivery are not guaranteed. You’d have to develop your own mechanism to ensure robust messaging (e.g., adding sequencing information to messages themselves). 

• SignalR offers a limited number of client SDKs: C#, Java, Python, and JavaScript. There are no SDKs for platforms and languages like iOS, Android, Go, Ruby, or PHP.

• Scaling ASP.NET Core SignalR is difficult, expensive, and time-consuming. You can abstract away the pain of managing SignalR yourself by using the managed version, Azure SignalR Service. However, SignalR Service has its limitations; for example, it provides a 99.95% uptime guarantee for premium accounts, which amounts to almost 4.5 hours of downtime per year. The situation is worse for non-premium accounts, where the SLA provided is 99.9% (almost 9 hours of annual downtime).  

Read about the challenges of scaling SignalR

We’ll now compare the features and capabilities of Pusher and SignalR to highlight their similarities and differences. We’ll also cover Pusher and SignalR use cases, and discuss when it’s best to use each of these two solutions.   

The table below compares Pusher and SignalR features and capabilities. Note that this comparison is created based on documentation and resources freely available online. If you do find anything incorrect or out of date, then please let us know.

Both Pusher and SignalR allow you to power realtime content updates and low-latency communication (primarily over WebSockets) for use cases such as:

• Live chat. 1-to-1 chat, chat rooms, chat bots, support chat, in-game chat.

• Data broadcast. High-frequency data updates sent in a 1-to-many fashion, such as live scores and traffic updates, live captions, voting, polling, and auction apps. 

• Multiplayer collaboration. Whiteboards and co-authoring apps (such as Google Docs).

• Data synchronization between backend components and frontend clients. 

• Notifications across social media and chat apps, online marketplaces, gaming, travel and transportation, etc.

• Live location tracking for logistics, fleet management, urban mobility, and food delivery apps. 

As they address similar use cases, you’re probably wondering: when is it best to use Pusher, and when to use SignalR?

Pusher is a better choice than SignalR if:

• You’re looking to build realtime functionality using pub/sub over WebSockets.

• You need to support a wide variety of client platforms, including JavaScript, Android, iOS, Unity, and Flutter.  

• You need capabilities like native push notifications and presence.  

You should SignalR instead of Pusher if:

• You’re a .NET developer or you need to integrate with the .NET and Azure ecosystems (e.g., Blazor, Microsoft Azure Functions). 

• You need a solution that supports various calling patterns (RPC and streaming) and multiple transports (WebSocket, but also Server-Sent Events and HTTP long polling).

• You want to handle realtime infrastructure yourself (on-prem) rather than offloading this responsibility to a third-party cloud service. You can do this by using the open-source version, ASP.NET Core SignalR. 

We hope this article is a good starting point for you to discover the advantages, disadvantages, similarities, and differences between Pusher and SignalR. While both Pusher and SignalR are solutions that simplify building real time web functionality powered by WebSockets, they come with some drawbacks. Among them:

• Both are single-region solutions, which may lead to issues such as increased latency for some users, and unreliability (single point of failure and congestion).

• Both Pusher and SignalR lack some features that would make building realtime functionality faster and more convenient. For example, Pusher lacks capabilities like message history, and offers no managed integrations with third-party solutions like serverless platforms and event-streaming platforms (e.g., Kafka). Meanwhile, SignalR lacks features like presence and push notifications, and only offers integrations with the .NET/Azure ecosystem.  

• Pusher and SignalR offer weak data integrity assurances (message delivery is not guaranteed, especially when disconnections and unreliable network conditions are involved). 

It is ultimately up to you to decide if Pusher/SignalR is the best choice for your realtime use case. However, if you’re interested in further weighing your options, here are some alternative solutions you can explore:

• Pusher alternatives

• SignalR alternatives

Ably is a realtime experience infrastructure provider. Our APIs, SDKs, and managed integrations help developers build and deliver realtime apps and features without having to worry about maintaining and scaling messy realtime infrastructure. 

Key Ably features and capabilities:

• Pub/sub messaging over serverless WebSockets, with rich features such as message delta compression, automatic reconnections with continuity, user presence, message history, and message interactions.

• Support for several other protocols: Server-Sent Events, MQTT, Raw HTTP, AMQP, STOMP.

• Push notifications.

• Client SDKs for every major programming language and development platform. 

• Custom webhooks and integrations with streaming solutions like Apache Kafka & Amazon Kinesis, and serverless platforms such as AWS Lambda, Microsoft Azure Functions, and Google Cloud Functions. 

• A globally-distributed network of datacenters and edge acceleration points-of-presence. 

• Guaranteed message ordering and delivery. 

• Global fault tolerance and a 99.999% uptime SLA.

• < 65ms round-trip latency (P99).

• Dynamic elasticity, so we can quickly scale to handle any demand (billions of messages sent to millions of pub/sub channels and WebSocket connections). 

Find out more about Ably and how we can help with your realtime use case:

• See how Ably compares to SignalR

• See how Ably compares to Pusher

• Explore Ably’s product documentation