Como usar o wsocket.io SDK: Node.js (Publisher) + JavaScript (Subscriber) — Guia completo com exemplos

Se você precisa de comunicação realtime na sua aplicação — chat, dashboard ao vivo, notificações, IoT — o wsocket.io resolve com 5 linhas de código. Neste guia eu mostro como usar o Node.js SDK (publisher/backend) e o JavaScript SDK (subscriber/browser) do zero até produção.

TL;DR: Instale o SDK, conecte com sua API key, publique em canais e receba eventos no browser. Sem servidor WebSocket pra manter, sem Redis pra configurar, sem dor de cabeça com reconexão.

---

O que é o wsocket.io?

O wsocket.io é uma plataforma de infraestrutura realtime que oferece:

• Pub/Sub com canais — publique de qualquer backend, receba em qualquer frontend
• Presença — saiba quem está online em tempo real
• Histórico — replay de mensagens perdidas
• Push Notifications — Web Push, FCM, APNs
• Webhooks — callbacks HTTP assinados com HMAC-SHA256
• 16 SDKs — Node.js, Python, Go, Rust, Java, C#, PHP, Ruby, Kotlin, Swift, Dart, Elixir, C, C++, Pascal

Latência média < 5ms. Free tier com 100 conexões e 10K mensagens/dia.

---

1. Criando sua conta e API Key

1. Acesse wsocket.io/register e crie uma conta gratuita
2. No dashboard, clique em “Create App”
3. Copie a API Key gerada (formato: wsk_...)

# Sua API Key será algo como:
wsk_live_abc123def456...

---

2. Instalando o SDK no Node.js (Backend/Publisher)

npm install @wsocket-io/sdk

Ou com yarn/pnpm:

yarn add @wsocket-io/sdk
# ou
pnpm add @wsocket-io/sdk

Conexão básica

// server.js
const { WSocket } = require('@wsocket-io/sdk');

const client = new WSocket({
  url: 'wss://node00.wsocket.online',
  apiKey: 'wsk_live_SUA_API_KEY'
});

await client.connect();
console.log('✅ Conectado ao wsocket.io');

Publicando em um canal

// Publicar uma mensagem no canal "chat:general"
const channel = client.channel('chat:general');

await channel.publish({
  user: 'Alice',
  text: 'Hello everyone! 🚀',
  ts: Date.now()
});

Publicando mensagens diretas

// Mensagem direta para um usuário específico
const inbox = client.channel('user:bob:inbox');

await inbox.publish({
  type: 'dm',
  from: 'Alice',
  text: 'Mensagem privada!',
  ts: Date.now()
});

---

3. Integrando com Express.js

O caso mais comum é publicar eventos a partir de uma API REST:

// routes/notifications.js
const express = require('express');
const { WSocket } = require('@wsocket-io/sdk');
const router = express.Router();

const ws = new WSocket({
  url: 'wss://node00.wsocket.online',
  apiKey: process.env.WSOCKET_API_KEY
});

// Conectar uma vez na inicialização
ws.connect();

// POST /api/notify — publica evento para todos os subscribers
router.post('/notify', async (req, res) => {
  const { channel, message } = req.body;

  await ws.channel(channel).publish({
    ...message,
    ts: Date.now()
  });

  res.json({ ok: true, channel });
});

// POST /api/order-update — notifica status de pedido
router.post('/order-update', async (req, res) => {
  const { orderId, status } = req.body;

  await ws.channel(`order:${orderId}`).publish({
    event: 'status_changed',
    status,  // 'confirmed' | 'preparing' | 'shipped' | 'delivered'
    ts: Date.now()
  });

  res.json({ ok: true });
});

module.exports = router;

---

4. JavaScript SDK no Browser (Subscriber)

No frontend, a forma mais simples é usar WebSocket nativo:

<!-- index.html -->
<script>
  const API_KEY = 'wsk_live_SUA_API_KEY';
  const ws = new WebSocket(`wss://node00.wsocket.online/?key=${API_KEY}`);

  ws.onopen = () => {
    console.log('✅ Conectado');

    // Inscrever-se no canal
    ws.send(JSON.stringify({
      action: 'subscribe',
      channel: 'chat:general'
    }));
  };

  ws.onmessage = (event) => {
    const msg = JSON.parse(event.data);

    if (msg.action === 'message') {
      console.log('📩 Nova mensagem:', msg.data);
      // Renderizar no DOM...
    }
  };

  ws.onclose = () => {
    console.log('🔌 Desconectado — reconectando...');
    // Implementar lógica de reconexão
  };
</script>

Com o SDK JavaScript (recomendado)

npm install @wsocket-io/sdk

// app.js (React, Vue, Svelte, etc.)
import { WSocket } from '@wsocket-io/sdk';

const client = new WSocket({
  url: 'wss://node00.wsocket.online',
  apiKey: 'wsk_live_SUA_API_KEY'
});

await client.connect();

// Inscrever-se em um canal
const channel = client.channel('chat:general');

channel.on('message', (data) => {
  console.log('Nova mensagem recebida:', data);
});

// Inscrever-se em múltiplos canais
client.channel('notifications:*').on('message', (data) => {
  console.log('Notificação:', data);
});

---

5. Exemplo completo: Chat em tempo real

Backend (Node.js + Express)

// server.js
const express = require('express');
const { WSocket } = require('@wsocket-io/sdk');

const app = express();
app.use(express.json());

const ws = new WSocket({
  url: 'wss://node00.wsocket.online',
  apiKey: process.env.WSOCKET_API_KEY
});
ws.connect();

// Enviar mensagem de chat
app.post('/api/chat/send', async (req, res) => {
  const { room, user, text } = req.body;

  await ws.channel(`chat:${room}`).publish({
    user,
    text,
    ts: Date.now()
  });

  res.json({ ok: true });
});

app.listen(3000, () => console.log('Server rodando na porta 3000'));

Frontend (React)

// Chat.jsx
import { useEffect, useState, useRef } from 'react';

export function Chat({ room, apiKey }) {
  const [messages, setMessages] = useState([]);
  const [input, setInput] = useState('');
  const wsRef = useRef(null);

  useEffect(() => {
    const ws = new WebSocket(`wss://node00.wsocket.online/?key=${apiKey}`);

    ws.onopen = () => {
      ws.send(JSON.stringify({
        action: 'subscribe',
        channel: `chat:${room}`
      }));
    };

    ws.onmessage = (e) => {
      const msg = JSON.parse(e.data);
      if (msg.action === 'message') {
        setMessages(prev => [...prev, msg.data]);
      }
    };

    wsRef.current = ws;
    return () => ws.close();
  }, [room]);

  const send = async () => {
    await fetch('/api/chat/send', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ room, user: 'Eu', text: input })
    });
    setInput('');
  };

  return (
    <div>
      <div className="messages">
        {messages.map((m, i) => (
          <div key={i}><strong>{m.user}:</strong> {m.text}</div>
        ))}
      </div>
      <input value={input} onChange={e => setInput(e.target.value)} />
      <button onClick={send}>Enviar</button>
    </div>
  );
}

---

6. Recursos avançados

Presença (quem está online)

// No browser — entrar na sala
ws.send(JSON.stringify({
  action: 'presence.enter',
  channel: 'chat:general',
  data: { name: 'Alice', avatar: '/alice.png' }
}));

// Sair da sala
ws.send(JSON.stringify({
  action: 'presence.leave',
  channel: 'chat:general'
}));

Histórico de mensagens

// Buscar últimas 50 mensagens do canal
ws.send(JSON.stringify({
  action: 'history',
  channel: 'chat:general',
  limit: 50
}));

Wildcards (inscrição em múltiplos canais)

// Receber TODAS as notificações — qualquer sub-canal
ws.send(JSON.stringify({
  action: 'subscribe',
  channel: 'notifications:*'
}));

// Recebe: notifications:orders, notifications:alerts, notifications:system, etc.

---

7. Segurança

O wsocket.io oferece múltiplas camadas de segurança:

• JWT Tokens — Autenticação por token com claims customizáveis
• API Keys com permissões granulares — read-only, write-only, admin
• Rate Limiting — Configurável por app
• E2E Encryption — Criptografia fim-a-fim (plano Enterprise)

// Exemplo com JWT token no browser
const ws = new WebSocket('wss://node00.wsocket.online/?token=eyJhbGciOi...');

---

8. SDKs disponíveis

O wsocket.io oferece SDKs para 16 linguagens. Todos os publishers funcionam da mesma forma — conecte, publique, pronto:

Linguagem	Instalar	Repositório
Node.js / JS	npm i @wsocket-io/sdk	sdk-js
Python	pip install wsocket-io	sdk-python
Go	go get github.com/wsocket-io/sdk-go	sdk-go
C# / .NET	dotnet add WSocket.IO	sdk-csharp
Java	io.wsocket:sdk	sdk-java
Kotlin	io.wsocket:sdk-kotlin	sdk-kotlin
Rust	cargo add wsocket-io	sdk-rust
PHP	composer require wsocket-io/sdk	sdk-php
Ruby	gem install wsocket-io	sdk-ruby
Swift	Swift Package Manager	sdk-swift
Dart	dart pub add wsocket_io	sdk-dart
Elixir	{:wsocket_io, "~> 1.0"}	sdk-elixir
C	Header-only	sdk-c
C++	Header-only	sdk-cpp
Pascal	Unit include	sdk-pascal

---

9. Pricing

Plano	Preço	Conexões	Mensagens/dia
Free	Grátis	100	10K
Pro	$49/mês	10K	1M
Enterprise	Custom	Ilimitado	Ilimitado

O plano Free é permanente — sem cartão de crédito, sem trial de 14 dias. Perfeito para desenvolvimento, side projects e MVPs.

---

Conclusão

O wsocket.io simplifica drasticamente a implementação de funcionalidades realtime. Em vez de manter infraestrutura WebSocket própria (Redis, load balancing, reconexão, scaling), você:

1. Instala o SDK (npm i @wsocket-io/sdk)
2. Conecta com API key (1 linha)
3. Publica eventos de qualquer backend (channel.publish())
4. Recebe no browser (ws.onmessage)

Tudo gerenciado — scaling, reconexão, histórico, presença, push.

Links:

• 📖 Documentação completa
• 🚀 Criar conta gratuita
• 💻 GitHub — wsocket-io
• 📦 SDK Node.js