# Apinator

> Free WebSocket server for realtime apps. Unlimited connections, channels, and messages — no payment required. Drop-in Pusher alternative with SDKs for 7 languages.

Apinator is a free, self-hosted or managed WebSocket infrastructure platform. It provides channels, presence tracking, and event broadcasting — API-compatible with Pusher. No per-message billing, no tiers, no credit card required.

## Core Pages

- [Home](https://apinator.io/): Free WebSocket server and realtime API platform overview
- [Documentation](https://apinator.io/documentation/): Full API reference, SDK setup guides, channel auth, and webhooks
- [Blog](https://apinator.io/blog/): Tutorials and guides for building realtime features

## Framework Guides

- [Next.js](https://apinator.io/for/nextjs/): Add WebSocket channels and real-time notifications to Next.js. Works with App Router and Pages Router — no dedicated WebSocket server needed.
- [React](https://apinator.io/for/react/): Add WebSocket channels and real-time notifications to any React app. Subscribe in useEffect, bind events declaratively, clean up automatically — works with Vite, Create React App, and Remix.
- [Python](https://apinator.io/for/python/): Trigger real-time WebSocket events from Django, Flask, and FastAPI. Zero-dependency server SDK using only the Python standard library — no WebSocket server to run or manage.
- [Laravel](https://apinator.io/for/laravel/): Trigger real-time WebSocket events from Laravel controllers, jobs, and queued tasks. Zero-dependency PHP SDK — no Guzzle, no Reverb, no Echo server to configure or maintain.
- [Go](https://apinator.io/for/go/): Publish real-time WebSocket events from Go HTTP handlers, background workers, or CLI tools. Stdlib-only server SDK — zero external dependencies, context-aware, idiomatic error handling.
- [Vue.js](https://apinator.io/for/vue/): Add WebSocket channels and real-time notifications to Vue 3 and Nuxt apps. Composable-friendly SDK that pairs naturally with reactive refs, onMounted, and onUnmounted lifecycle hooks.
- [SvelteKit](https://apinator.io/for/sveltekit/): Add WebSocket channels and real-time events to SvelteKit with Svelte 5 runes. Type-safe server SDK for API routes and form actions. Works with $state, onMount, and $env secrets.
- [Swift](https://apinator.io/for/swift/): Add real-time WebSocket notifications to iOS and macOS apps with a native Swift SDK. Built on URLSessionWebSocketTask — no third-party WebSocket library needed. SPM-ready for iOS 13+ and macOS 10.15+.
- [Kotlin](https://apinator.io/for/kotlin/): Add real-time WebSocket notifications to Android apps with a native Kotlin SDK. Built on OkHttp WebSocket, Gradle-ready, lifecycle-aware, and compatible with Jetpack Compose StateFlow.

## Use Cases

- [Live Chat & Messaging](https://apinator.io/use-cases/live-chat/): Build realtime chat experiences with channels, typing indicators, and message history.
- [Live Notifications & Activity Feeds](https://apinator.io/use-cases/notifications/): Deliver instant notifications and live activity feeds to your users.
- [Collaborative Editing](https://apinator.io/use-cases/collaborative-editing/): Build Google Docs-style collaboration with live cursors and realtime sync.
- [Live Dashboards & Analytics](https://apinator.io/use-cases/dashboards/): Stream metrics, charts, and KPIs to dashboards in real time.
- [Multiplayer Gaming](https://apinator.io/use-cases/multiplayer-gaming/): Synchronize game state across players with low-latency WebSockets.
- [Live Auctions & Bidding](https://apinator.io/use-cases/auctions/): Build realtime auction platforms with instant bid updates and countdown timers.

## Comparisons & Guides

- [The Free Pusher Alternative](https://apinator.io/pusher-alternative/): All the WebSocket channels, presence, and event broadcasting you rely on — without per-message billing.
- [A More Affordable Ably Alternative](https://apinator.io/ably-alternative/): Realtime WebSocket infrastructure without the enterprise pricing.
- [Self-Hosted WebSocket Server for Production](https://apinator.io/self-hosted-websocket/): Deploy realtime infrastructure on your own servers. Full control, no vendor lock-in, predictable costs.
- [Free WebSocket Server — Self-Hosted](https://apinator.io/free-websocket-server/): Production-ready WebSocket infrastructure. Free to use, deploy anywhere, no payment required.
- [WebSockets vs Server-Sent Events (SSE)](https://apinator.io/websocket-vs-sse/): Two protocols for realtime data — each with the right use case.
- [How WebSockets Scale at Production](https://apinator.io/how-websockets-scale/): The architecture behind distributed WebSocket infrastructure — from a single server to multi-region.

## Blog Posts

- [Building a Realtime Dashboard with Apinator](https://apinator.io/blog/building-a-realtime-dashboard-with-apinator/): Learn how to build a live analytics dashboard that updates in real time using Apinator WebSockets, with less than 20 lines of client code.
- [How to Build a Live Collaborative Document Editor](https://apinator.io/blog/how-to-build-a-live-collaborative-document-editor/): Learn how to build a Google Docs-style collaborative editor with real-time cursor tracking, live edits, and presence indicators using WebSockets.
- [What Is WebSocket Infrastructure?](https://apinator.io/blog/what-is-websocket-infrastructure/): WebSocket infrastructure is the layer that manages persistent connections at scale — handling auth, routing, fanout, and delivery so your app doesn't have to.
- [How to Build a Crypto / Stock Price Ticker with WebSockets](https://apinator.io/blog/how-to-build-a-crypto-stock-price-ticker/): Build a live price ticker that updates in real time — polling an external price feed on the server and pushing updates to all clients instantly via WebSockets.
- [How to Scale WebSockets to 1 Million Connections](https://apinator.io/blog/how-to-scale-websocket-to-1-million-connections/): Scaling WebSockets beyond a single server requires careful architecture. Here's what actually breaks and how to fix it — from sticky sessions to Redis fanout and horizontal scaling.
- [How to Build a Live Voting and Polling System](https://apinator.io/blog/how-to-build-a-live-voting-polling-system/): Build a real-time voting system where results update live as votes come in — no refresh needed. Perfect for Q&A sessions, live events, and audience interaction.
- [WebSockets vs HTTP Polling](https://apinator.io/blog/websockets-vs-http-polling/): Polling gets the job done until it doesn't. Here's an honest comparison of WebSockets and HTTP polling — latency, server load, complexity, and when to use each.
- [How to Build a Multiplayer Game with WebSockets](https://apinator.io/blog/how-to-build-a-multiplayer-game-with-websockets/): Build a real-time multiplayer game using WebSockets — from game state synchronization to player presence and input broadcasting, with a working example.
- [Redis Pub/Sub Explained](https://apinator.io/blog/redis-pubsub-explained/): Redis Pub/Sub is the backbone of most WebSocket scaling architectures. Here's how it works, what it's good at, and where it falls short.
- [How to Add Realtime to a Next.js App](https://apinator.io/blog/how-to-add-realtime-to-nextjs/): Add live WebSocket features to your Next.js app — from server-side event publishing in Route Handlers to client-side subscriptions with a custom React hook.
- [Presence Channels Explained](https://apinator.io/blog/presence-channels-explained/): Presence channels let you track who's online in real time — showing typing indicators, viewer counts, and live cursors without building your own member tracking.
- [How to Add Realtime to a Laravel App](https://apinator.io/blog/how-to-add-realtime-to-laravel/): Add WebSocket-powered realtime features to your Laravel application — publishing events from controllers and subscribing from the frontend with a few lines of code.
- [How to Build Live Customer Support Chat](https://apinator.io/blog/how-to-build-live-customer-support-chat/): Build a live chat widget for your product — a customer-facing chat window and an agent dashboard that both update in real time using WebSockets.
- [How to Build Slack with WebSockets](https://apinator.io/blog/how-to-build-slack-with-websockets/): Slack's realtime features — channel messages, typing indicators, online presence, and notifications — can all be built with WebSockets. Here's how the architecture works.
- [How to Build Realtime Chat in Node.js](https://apinator.io/blog/how-to-build-realtime-chat-in-nodejs/): A step-by-step guide to building a working realtime chat app with Node.js and Apinator — from server setup to client subscription in under 50 lines of code.
- [WebSocket Load Balancing Explained](https://apinator.io/blog/websocket-load-balancing-explained/): Load balancing WebSockets is trickier than HTTP — persistent connections and stateful servers mean round-robin doesn't cut it. Here's what actually works.
- [What Is a WebSocket?](https://apinator.io/blog/what-is-a-websocket/): WebSockets let servers push data to clients the moment it changes — no polling, no waiting. Here's how they work, what they're good for, and when to use them.
- [How the WebSocket Handshake Works](https://apinator.io/blog/how-the-websocket-handshake-works/): The WebSocket connection starts as HTTP and upgrades to a persistent socket. Here's exactly what happens during the handshake — headers, keys, and all.
- [What Is a Pub/Sub Channel?](https://apinator.io/blog/what-is-a-pubsub-channel/): Pub/sub channels are the core abstraction in realtime systems — they let publishers send messages to many subscribers without knowing who's listening. Here's how they work.
- [WebSocket Protocol Explained](https://apinator.io/blog/websocket-protocol-explained/): A practical guide to the WebSocket protocol — how connections are established, how frames are structured, what opcodes do, and what all of this means when you're building realtime apps.