WebSockets

Track professional padel matches point-by-point as they happen. The Padel API provides two ways to get live data: a REST endpoint for polling and WebSocket channels for instant push updates.

REST Polling

Fetch the latest match state on demand. Simple to implement, works everywhere.

Receive updates instantly via Pusher. No polling, no delays.

Looking for resource changes rather than point-by-point data? Use Webhooks instead — they push notifications when a tournament, match, or player is created, updated, or deleted, without keeping a connection open.

Prerequisites

Before you begin, make sure you have:

A Padel API account (sign up here)
An API token from your API Tokens page

Step 1: Find Live Matches

First, discover which matches are currently being played using GET /api/live:

curl -X GET \
  'https://padelapi.org/api/live' \
  -H 'Authorization: Bearer YOUR_API_TOKEN'

const response = await fetch('https://padelapi.org/api/live', {
  headers: { 'Authorization': 'Bearer YOUR_API_TOKEN' }
});

const liveMatches = await response.json();
console.log(liveMatches.data);

import requests

response = requests.get(
    'https://padelapi.org/api/live',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'}
)

live_matches = response.json()
print(live_matches['data'])

This returns a list of all matches with status: "live". Each match includes its id, which you’ll use in the next steps.

Step 2: Get the Live Match State

Once you have a match ID, fetch its point-by-point data with GET /api/matches/{id}/live:

curl -X GET \
  'https://padelapi.org/api/matches/7243/live' \
  -H 'Authorization: Bearer YOUR_API_TOKEN'

Response structure

{
  "id": 7243,
  "self": "/api/matches/7243/live",
  "status": "live",
  "coverage": "full",
  "channel": "matches.7243",
  "sets": [
    {
      "set_number": 1,
      "set_score": "6-2",
      "games": [
        {
          "game_number": 1,
          "game_score": "0 - 0",
          "serving": "team_1",
          "points": ["15:0", "30:0", "40:15"]
        },
        {
          "game_number": 2,
          "game_score": "1 - 0",
          "serving": "team_2",
          "points": ["0:0", "15:0", "30:0", "40:0", "40:15"]
        }
      ]
    },
    {
      "set_number": 2,
      "set_score": null,
      "games": [
        {
          "game_number": 1,
          "game_score": "0 - 0",
          "serving": "team_1",
          "points": ["0:0", "15:0", "30:0"]
        }
      ]
    }
  ],
  "connections": {
    "match": "/api/matches/7243"
  }
}

Field reference

Field	Description
`status`	Match status in a live context: `live`, `ended`, or `finished`. See Match Statuses for all possible values.
`coverage`	Data completeness: `tracking` (collecting data), `full` (all games tracked), `partial` (some gaps), or `null` (no data)
`channel`	Pusher channel name for real-time updates
`sets[].set_number`	Set number (1, 2, or 3)
`sets[].set_score`	Final set score (e.g. `"6-2"`) when complete, `null` while in progress
`sets[].games[].game_number`	Game number within the set
`sets[].games[].game_score`	Cumulative set score before this game started (e.g. `"3 - 1"`)
`sets[].games[].serving`	Serving team: `"team_1"`, `"team_2"`, or `null` if unknown
`sets[].games[].points`	Array of point scores during the game (format `"team1:team2"`)

The channel field is the exact Pusher channel name you need for Step 3 — use it directly, no need to construct it manually.

Instead of polling the REST endpoint repeatedly, subscribe to WebSocket updates for instant notifications on every point.

Connection details

Parameter	Value
Provider	Pusher
App Key	`0ffbefeb945e4e466065`
Cluster	`eu`
Channel format	`matches.{matchId}`
Event name	`App\PadelApi\Events\MatchLiveUpdated`

Channels are public — no authentication handshake is required to subscribe. You only need the Pusher app key and cluster.

Install a Pusher client

npm install pusher-js

pip install pysher

import Pusher from 'pusher-js';

const pusher = new Pusher('0ffbefeb945e4e466065', {
  cluster: 'eu'
});

// Subscribe using the "channel" field from the live endpoint
const channel = pusher.subscribe('matches.7243');

channel.bind('App\\PadelApi\\Events\\MatchLiveUpdated', (data) => {
  console.log('Match update:', data.status);
  console.log('Sets:', data.sets);
  // data has the same structure as the /live REST response
});

import pysher
import json

def on_event(data):
    match = json.loads(data)
    print(f"Match update: {match['status']}")
    print(f"Sets: {match['sets']}")

pusher = pysher.Pusher(key='0ffbefeb945e4e466065', cluster='eu')
pusher.connection.bind('pusher:connection_established', lambda _: None)
pusher.connect()

channel = pusher.subscribe('matches.7243')
channel.bind('App\\PadelApi\\Events\\MatchLiveUpdated', on_event)

The WebSocket event payload has the same structure as the REST response — id, self, status, coverage, channel, sets, and connections.

Step 4: Handle Match Completion

When a match ends, you will receive two final events in sequence:

ended — the match is over, but results are still being confirmed
finished — the match is fully closed and results are final

See Match Statuses for details. You can react to either status depending on your use case — unsubscribe from the channel once you receive finished:

channel.bind('App\\PadelApi\\Events\\MatchLiveUpdated', (data) => {
  updateScoreboard(data);

  if (data.status === 'ended') {
    console.log('Match ended, waiting for final confirmation...');
  }

  if (data.status === 'finished') {
    pusher.unsubscribe('matches.7243');
    console.log('Match finished, unsubscribed');
  }
});

def on_event(data):
    match = json.loads(data)
    update_scoreboard(match)

    if match['status'] == 'ended':
        print('Match ended, waiting for final confirmation...')

    if match['status'] == 'finished':
        pusher.unsubscribe('matches.7243')
        print('Match finished, unsubscribed')

Recommended Workflow

Find live matches — GET /api/live
Get initial state — GET /api/matches/{id}/live
Subscribe to updates — Connect to Pusher channel matches.{id}
Detect match end — When status changes to ended (match over) and then finished (results confirmed), unsubscribe from the channel

Tips

REST polling vs WebSockets vs Webhooks — when to use which

Use REST polling when you need a simple integration, are building server-side batch processes, or your environment doesn’t support persistent connections. Use WebSockets for user-facing applications where latency matters — live scoreboards, mobile apps, or real-time dashboards. Use Webhooks for backend integrations that react to resource changes (match created, score finalised, player merged) — server-to-server, no persistent connection, signed payloads. WebSockets and Webhooks solve different problems: point-by-point during play vs. notifications when something changes.

Not all matches have live data

The coverage field indicates whether any points were lost during tracking. full means every point was captured, partial means some points were missed due to source feed gaps, and tracking means the match is live and data is being collected. Check this field before relying on point-level completeness.

Handling reconnections

Pusher clients handle reconnections automatically. If the connection drops, the client will reconnect and resubscribe to channels. However, you may miss events during the disconnection — fetch the latest state from the REST endpoint after reconnecting to fill any gaps.

Rate limits for the REST endpoint

If you choose REST polling over WebSockets, avoid polling more frequently than once every 10 seconds per match. For lower latency, use WebSockets instead.

Next steps

Live Match Endpoint

Full reference for the point-by-point endpoint

Live Matches Endpoint

Discover every match currently in progress

Webhooks

Server-to-server push for tournament, match, and player changes

Match Statistics

Combine live tracking with post-match stats analysis

API Reference

Full endpoint documentation with parameters and responses

Overview

API Endpoints

Reference

WebSockets

REST Polling

WebSockets

Prerequisites

Step 1: Find Live Matches

Step 2: Get the Live Match State

Response structure

Field reference

Connection details

Install a Pusher client

Step 4: Handle Match Completion

Recommended Workflow

Tips

Next steps

Live Match Endpoint

Live Matches Endpoint

Webhooks

Match Statistics

API Reference

REST Polling

WebSockets

​Prerequisites

​Step 1: Find Live Matches

​Step 2: Get the Live Match State

​Response structure

​Field reference

​Step 3: Subscribe to Real-Time Updates

​Connection details

​Install a Pusher client

​Subscribe to a match channel

​Step 4: Handle Match Completion

​Recommended Workflow

​Tips

​Next steps

Live Match Endpoint

Live Matches Endpoint

Webhooks

Match Statistics

API Reference

Prerequisites

Step 1: Find Live Matches

Step 2: Get the Live Match State

Response structure

Field reference

Step 3: Subscribe to Real-Time Updates

Connection details

Install a Pusher client

Subscribe to a match channel

Step 4: Handle Match Completion

Recommended Workflow

Tips

Next steps