JavaScript (Node.js)
npm install socket.io socket.io-client
Python
pip install python-socketio eventlet
# or
pip install python-socketio aiohttp
Java
implementation 'io.socket:socket.io-client:2.0.1'
Swift (iOS)
pod 'Socket.IO-Client-Swift', '~> 16.0.1'
C# (.NET)
Install-Package SocketIoClientDotNet
React Native
npm install socket.io-client
Go
go get github.com/googollee/go-socket.io
Rust
cargo add socketio-client
Client
import { io } from 'socket.io-client';
const socket = io('http://localhost:3000');
Server
const io = require('socket.io')(3000, {
cors: { origin: '*' }
});
io.on('connection', (socket) => {
console.log('Client connected:', socket.id);
});
Client
import socketio
sio = socketio.Client()
sio.connect('http://localhost:3000')
Server
import socketio, eventlet, flask
app = flask.Flask(__name__)
sio = socketio.Server(cors_allowed_origins='*')
app = socketio.WSGIApp(sio, app)
@sio.event
def connect(sid, environ):
print('Client connected:', sid)
if __name__ == '__main__':
eventlet.wsgi.server(eventlet.listen(('', 3000)), app)
Client
IO.Options opts = new IO.Options();
Socket socket = IO.socket("http://localhost:3000", opts);
socket.connect();
Server
import io.socket.engineio.server.EngineIoServer;
import io.socket.server.SocketIoServer;
EngineIoServer engineIo = new EngineIoServer();
SocketIoServer io = new SocketIoServer(engineIo);
io.listen(3000);
io.on("connection", args -> {
var client = args[0];
System.out.println("Client connected: " + client.id());
});
Client
let manager = SocketManager(
socketURL: URL(string: "http://localhost:3000")!,
config: [.log(true), .compress]
)
let socket = manager.defaultSocket
socket.connect()
Server Server setups in Swift are uncommon; usually Node.js or Python is used.
Client
var socket = IO.Socket("http://localhost:3000");
socket.Connect();
Server
using Fleck;
var server = new WebSocketServer("ws://0.0.0.0:3000");
server.Start(socket =>
{
socket.OnOpen = () => Console.WriteLine("Client connected");
});
Client
import io from 'socket.io-client';
const socket = io('http://localhost:3000');
(Server side same as JavaScript above.)
Client
import "github.com/googollee/go-socket.io-client"
socket, err := gosocketio.Dial(
gosocketio.GetUrl("localhost", 3000, false),
transport.GetDefaultWebsocketTransport(),
)
Server
import (
"github.com/googollee/go-socket.io"
"net/http"
)
server, _ := socketio.NewServer(nil)
server.OnConnect("/", func(s socketio.Conn) error {
fmt.Println("Client connected:", s.ID())
return nil
})
http.Handle("/socket.io/", server)
go http.ListenAndServe(":3000", nil)
Client
use socketio_client::ClientBuilder;
async fn run() -> Result<(), Box<dyn std::error::Error>> {
let socket = ClientBuilder::new("http://localhost:3000")
.transport("websocket")
.connect()
.await?;
Ok(())
}
Server Rust server support is experimental; commonly use Node.js/Python servers.
Client
socket.emit('msg', 'Hi');
socket.on('reply', (data) => console.log('Reply:', data));
Server
io.on('connection', (socket) => {
socket.on('msg', (msg) => {
console.log('Received:', msg);
socket.emit('reply', 'Hello from server');
});
});
Client
sio.emit('msg', 'Hi')
@sio.on('reply')
def on_reply(data):
print('Reply:', data)
Server
@sio.event
def msg(sid, data):
print('Received:', data)
sio.emit('reply', 'Hello from server', to=sid)
Client
socket.emit("msg", "Hi");
socket.on("reply", args -> System.out.println("Reply: " + args[0]));
Server
io.on("connection", args -> {
var client = args[0];
client.on("msg", msgArgs -> {
System.out.println("Received: " + msgArgs[0]);
client.emit("reply", "Hello from server");
});
});
Client
socket.emit("msg", "Hi")
socket.on("reply") { data, _ in
print("Reply:", data[0])
}
Server Server side in Swift is rare; use Node.js/Python.
Client
socket.Emit("msg", "Hi");
socket.On("reply", data => Console.WriteLine("Reply: " + data));
Server
socket.OnMessage = message =>
{
Console.WriteLine("Received: " + message);
socket.Send("reply", "Hello from server");
};
Client
socket.Emit("msg", "Hi")
socket.On("reply", func(msg string) {
fmt.Println("Reply:", msg)
})
Server
server.OnEvent("/", "msg", func(s socketio.Conn, msg string) {
fmt.Println("Received:", msg)
s.Emit("reply", "Hello from server")
})
Client
socket.emit("msg", Payload::String("Hi"));
socket.on("reply", |payload| println!("Reply: {:?}", payload));
Server Experimental; typically use Node.js/Python.
Join a room:
// JavaScript/Python/C#/etc.
socket.emit('join', 'room1');
socket.on('msg', (data) => console.log('Room message:', data));
Node.js
io.on('connection', (socket) => {
socket.on('join', (room) => {
socket.join(room);
io.to(room).emit('msg', 'Hello Room');
});
});
Python
@sio.event
def join(sid, room):
sio.enter_room(sid, room)
sio.emit('msg', 'Hello Room', room=room)
Go
server.OnEvent("/", "join", func(s socketio.Conn, room string) {
s.Join(room)
server.BroadcastToRoom("/", room, "msg", "Welcome")
})
socket.on('disconnect', (reason) => console.log('Disconnected:', reason));
socket.on('connect_error', (err) => console.error('Connection error:', err));
@sio.event
def disconnect():
print('Disconnected')
@sio.event
def connect_error(data):
print('Connection error:', data)
// Go client library varies; similar patterns apply.
io.on('connection', (socket) => {
socket.on('disconnect', (reason) =>
console.log('Client disconnected:', reason)
);
});
server.OnDisconnect("/", func(s socketio.Conn, reason string) {
fmt.Println("Client disconnected:", reason)
})
const adminSocket = io('/admin');
sio.connect('http://localhost:3000/admin', namespaces=['/admin'])
io.of('/admin').on('connection', (socket) => {
console.log('Admin connected:', socket.id);
});
server.Of("/admin").OnConnect(func(s socketio.Conn) {
fmt.Println("Admin connected:", s.ID())
})
const socket = io('http://localhost:3000', {
auth: { token: 'abc' }
});
sio.connect('http://localhost:3000', auth={'token': 'abc'})
io.use((socket, next) => {
const token = socket.handshake.auth.token;
token === 'abc' ? next() : next(new Error('Auth error'));
});
Log events:
socket.onAny((event, ...args) => console.log(event, args));
Inspect network in browser devtools.
JavaScript
DEBUG=socket.io* node server.js
Python
import logging
logging.getLogger('socketio').setLevel(logging.DEBUG)
Go Print handler errors and use middleware for structured logs.
Client (Rarely needed)
Server
io.use((socket, next) => {
console.log('Middleware:', socket.id);
next();
});
server.Use(func(s socketio.Conn, next func()) {
fmt.Println("Middleware triggered:", s.ID())
next()
})
Client
fetch('/file')
.then((res) => res.arrayBuffer())
.then((buf) => socket.emit('file', buf));
Server
server.OnEvent("/", "file", func(s socketio.Conn, data []byte) {
ioutil.WriteFile("upload", data, 0644)
})