How do I send WebSocket events from a Go HTTP handler?

Call client.Trigger(ctx, apinator.TriggerParams{Name: "event", Channel: "channel", Data: `{"key":"value"}`}) from any http.HandlerFunc. The call is synchronous and returns an error if the publish fails.

Does the Go SDK use any external dependencies?

No. The SDK uses only Go standard library packages — net/http, crypto/hmac, encoding/json. It adds zero entries to your go.mod beyond the SDK itself.

Can I use Apinator with Gin, Echo, or Chi?

Yes. The SDK is framework-agnostic. Call client.Trigger() from any framework handler function, passing r.Context() for proper request-scoped cancellation.

How do I authenticate WebSocket channels in Go?

Create a POST HTTP handler that calls client.AuthenticateChannel(socketID, channelName, nil) and writes the JSON response. The JavaScript client SDK sends authentication requests to this endpoint automatically.

Is it free to publish WebSocket events from Go?

Yes. Apinator has a free plan with no credit card required. You can publish real-time WebSocket events from your Go service at no cost.

Server SDK

Realtime WebSocket Events 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.

Get Started Free View Docs

Server $ go get github.com/apinator-io/sdk-go

Client $ npm install @apinator/client

Publishing real-time WebSocket events from a Go service requires no additional infrastructure when you use Apinator. Make a single API call from any HTTP handler or goroutine to deliver an event to all subscribed browser clients. The Go SDK uses only the standard library — net/http, crypto/hmac, encoding/json — and adds zero dependencies to your go.mod file.

Quick Start

How to publish realtime WebSocket events from Go

Add realtime features to your Go app in a few steps.

Install the Go SDK

Add the module to your project. Zero dependencies — stdlib only.

go get github.com/apinator-io/sdk-go

Create a client

Initialize with app credentials and cluster. Uses the standard http.Client under the hood.

import "github.com/apinator-io/sdk-go"

client := apinator.NewClient(
    os.Getenv("REALTIME_APP_ID"),
    os.Getenv("REALTIME_KEY"),
    os.Getenv("REALTIME_SECRET"),
    os.Getenv("REALTIME_CLUSTER"),
)

Trigger WebSocket events

Publish real-time WebSocket events from HTTP handlers, background goroutines, or CLI tools. All subscribed clients receive the event instantly.

err := client.Trigger(ctx, apinator.TriggerParams{
    Name:    "new-order",
    Channel: "private-orders",
    Data:    `{"id":"ord_123","total":"$49.99"}`,
})

Authenticate channels

Add an HTTP handler that authenticates private channel subscriptions.

auth := client.AuthenticateChannel(
    socketID, channelName, nil,
)
// Returns ChannelAuthResponse{Auth: "key:sig"}

Why Go

Built for Go developers

Stdlib Only

Zero external dependencies. Uses net/http, crypto/hmac, and encoding/json from the standard library.

Context-Aware

All API methods accept context.Context for timeouts, cancellation, and tracing integration.

Functional Options

Configure with WithHost(), WithHTTPClient(), and more. Clean, extensible API without config structs.

Idiomatic Errors

Typed error types (AuthenticationError, ValidationError, ApiError) that work with errors.Is/As.

How WebSocket event publishing works from Go

A common pattern for Go web services is to push real-time updates to connected browser clients — for example, sending a dashboard update when a background job completes, or notifying users when an order status changes. The traditional approach requires running a WebSocket server alongside your Go HTTP server and managing client connections in memory, which adds complexity around connection state, scaling, and graceful shutdown.

Apinator separates the concerns cleanly: your Go service handles its domain logic and publishes events via a single HTTPS API call. Apinator's servers maintain the persistent WebSocket connections to browser clients and deliver the event in real-time, typically in under 100ms. Your Go service remains stateless with respect to WebSocket connections, which simplifies horizontal scaling — no sticky sessions required, no in-memory fan-out to coordinate.

The Go SDK wraps this API call idiomatically. All methods accept context.Context for cancellation and timeout propagation. Errors are typed so you can use errors.Is and errors.As. Configuration uses the functional options pattern — WithHost(), WithHTTPClient() — keeping the API clean and extensible. There are zero external dependencies; the module uses only Go's standard library.

Full Example

Full Example: Realtime WebSocket Events from a Go HTTP Server

Complete WebSocket example: Go HTTP handlers for private channel authentication and event publishing, plus a JavaScript frontend that receives real-time updates.

main.go

package main import ( "encoding/json" "net/http" "os" "github.com/apinator-io/sdk-go" ) var rt = apinator.NewClient( os.Getenv("REALTIME_APP_ID"), os.Getenv("REALTIME_KEY"), os.Getenv("REALTIME_SECRET"), os.Getenv("REALTIME_CLUSTER"), ) func main() { http.HandleFunc("POST /api/realtime/auth", authHandler) http.HandleFunc("POST /api/events", eventsHandler) http.ListenAndServe(":8080", nil) } func authHandler(w http.ResponseWriter, r *http.Request) { var body struct { SocketID string `json:"socket_id"` ChannelName string `json:"channel_name"` } json.NewDecoder(r.Body).Decode(&body) auth := rt.AuthenticateChannel(body.SocketID, body.ChannelName, nil) json.NewEncoder(w).Encode(auth) } func eventsHandler(w http.ResponseWriter, r *http.Request) { rt.Trigger(r.Context(), apinator.TriggerParams{ Name: "update", Channel: "private-dashboard", Data: `{"status":"deployed"}`, }) w.Write([]byte(`{"ok":true}`)) }

Related Docs

Read the core WebSocket guides

Related Use Cases

Explore realtime use cases

Live Dashboards & Analytics Multiplayer Gaming Live Auctions & Bidding

Start building realtime Go apps

Completely free. No credit card. No catch.

Get Started Free Read the Docs