Skip to main content
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.

WebSockets

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:

​
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'
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

FieldDescription
statusMatch status in a live context: live, ended, or finished. See Match Statuses for all possible values.
coverageData completeness: tracking (collecting data), full (all games tracked), partial (some gaps), or null (no data)
channelPusher channel name for real-time updates
sets[].set_numberSet number (1, 2, or 3)
sets[].set_scoreFinal set score (e.g. "6-2") when complete, null while in progress
sets[].games[].game_numberGame number within the set
sets[].games[].game_scoreCumulative set score before this game started (e.g. "3 - 1")
sets[].games[].servingServing team: "team_1", "team_2", or null if unknown
sets[].games[].pointsArray 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.

​
Step 3: Subscribe to Real-Time Updates

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

​
Connection details

ParameterValue
ProviderPusher
App Key0ffbefeb945e4e466065
Clustereu
Channel formatmatches.{matchId}
Event nameApp\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

​
Subscribe to a match channel

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
});
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:
  1. ended — the match is over, but results are still being confirmed
  2. 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');
  }
});
  1. Find live matches — GET /api/live
  2. Get initial state — GET /api/matches/{id}/live
  3. Subscribe to updates — Connect to Pusher channel matches.{id}
  4. Detect match end — When status changes to ended (match over) and then finished (results confirmed), unsubscribe from the channel

​
Tips

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.
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.
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.
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