Code example

class SoccerWebSocket {
  constructor(wsToken) {
    this.wsToken = wsToken;
    this.ws = null;
    this.subscriptions = new Set();
  }

  connect() {
    this.ws = new WebSocket(`wss://ws.soccerfootball.info/?token=${this.wsToken}`);

    this.ws.onopen = () => {
      console.log('Connected to Soccer Football WebSocket');
      // Resubscribe if reconnecting
      this.subscriptions.forEach(sub => {
        this.subscribe(sub.channel, sub.scope);
      });
    };

    this.ws.onmessage = (event) => {
      const message = JSON.parse(event.data);
      this.handleMessage(message);
    };

    this.ws.onclose = (event) => {
      console.log(`Connection closed: ${event.code} - ${event.reason}`);
      if (event.code !== 1000) {
        // Attempt reconnection after 5 seconds
        setTimeout(() => this.connect(), 5000);
      }
    };

    this.ws.onerror = (error) => {
      console.error('WebSocket error:', error);
    };
  }

  subscribe(channel, scope) {
    const message = {
      action: 'subscribe',
      channel: channel,
      scope: scope
    };
    this.ws.send(JSON.stringify(message));
    this.subscriptions.add({ channel, scope });
  }

  unsubscribe(channel, scope) {
    const message = {
      action: 'unsubscribe',
      channel: channel,
      scope: scope
    };
    this.ws.send(JSON.stringify(message));
    this.subscriptions.delete({ channel, scope });
  }

  ping() {
    this.ws.send(JSON.stringify({ action: 'ping' }));
  }

  handleMessage(message) {
    switch (message.type) {
      case 'match_start':
        console.log('Match started:', message.data);
        break;
      case 'goal':
        console.log('Goal!', message.data);
        break;
      case 'halftime':
        console.log('Halftime:', message.data);
        break;
      case 'match_end':
        console.log('Match ended:', message.data);
        break;
      case 'stats_update':
        console.log('Stats update:', message.data);
        break;
      case 'odds_update':
        console.log('Odds update:', message.data);
        break;
      case 'pong':
        console.log('Pong received');
        break;
      case 'subscribed':
        console.log('Subscribed to:', message.channel);
        break;
      case 'error':
        console.error('Error:', message.message);
        break;
    }
  }

  disconnect() {
    if (this.ws) {
      this.ws.close(1000, 'Client disconnect');
    }
  }
}

// Usage
const client = new SoccerWebSocket('your-websocket-token');
client.connect();

// Subscribe to all MAIN events
client.subscribe('MAIN', 'all');

// Subscribe to a specific match
client.subscribe('STATS', 'match:12345');

// Subscribe to a specific league
client.subscribe('ODDS', 'league:67890');

// Keep connection alive
setInterval(() => client.ping(), 30000);

import asyncio
import websockets
import json

class SoccerWebSocket:
    def __init__(self, ws_token):
        self.ws_token = ws_token
        self.ws = None
        self.subscriptions = set()

    async def connect(self):
        uri = f"wss://ws.soccerfootball.info/?token={self.ws_token}"

        async with websockets.connect(uri) as websocket:
            self.ws = websocket
            print("Connected to Soccer Football WebSocket")

            # Start message handler
            await self.handle_messages()

    async def handle_messages(self):
        async for message in self.ws:
            data = json.loads(message)
            await self.process_message(data)

    async def process_message(self, message):
        msg_type = message.get('type')

        if msg_type == 'match_start':
            print(f"Match started: {message.get('data')}")
        elif msg_type == 'goal':
            print(f"Goal! {message.get('data')}")
        elif msg_type == 'halftime':
            print(f"Halftime: {message.get('data')}")
        elif msg_type == 'match_end':
            print(f"Match ended: {message.get('data')}")
        elif msg_type == 'stats_update':
            print(f"Stats update: {message.get('data')}")
        elif msg_type == 'odds_update':
            print(f"Odds update: {message.get('data')}")
        elif msg_type == 'pong':
            print("Pong received")
        elif msg_type == 'subscribed':
            print(f"Subscribed to: {message.get('channel')}")
        elif msg_type == 'error':
            print(f"Error: {message.get('message')}")

    async def subscribe(self, channel, scope):
        message = {
            "action": "subscribe",
            "channel": channel,
            "scope": scope
        }
        await self.ws.send(json.dumps(message))
        self.subscriptions.add((channel, scope))

    async def unsubscribe(self, channel, scope):
        message = {
            "action": "unsubscribe",
            "channel": channel,
            "scope": scope
        }
        await self.ws.send(json.dumps(message))
        self.subscriptions.discard((channel, scope))

    async def ping(self):
        await self.ws.send(json.dumps({"action": "ping"}))

# Usage
async def main():
    client = SoccerWebSocket("your-websocket-token")

    async with websockets.connect(
        f"wss://ws.soccerfootball.info/?token={client.ws_token}"
    ) as ws:
        client.ws = ws

        # Subscribe to channels
        await client.subscribe("MAIN", "all")
        await client.subscribe("STATS", "match:12345")

        # Handle messages
        async for message in ws:
            data = json.loads(message)
            await client.process_message(data)

if __name__ == "__main__":
    asyncio.run(main())

Best Practices

Handle reconnections: Implement automatic reconnection with exponential backoff
Renew tokens proactively: Renew tokens 5 minutes before expiration
Use ping/pong: Send ping every 30 seconds to detect connection issues
Limit subscriptions: Only subscribe to channels and scopes you need
Process messages quickly: Don't block the message handler with heavy operations

PreviousODDS REALTIME NextErrors

Last updated 10 days ago

hashtagBest Practices

Best Practices