Como buscar classificações de todas as temporadas ativas

How to get standings for all current seasons

Neste tutorial veremos como buscar a classificação de todas as competições ativas da API.

In this tutorial we'll see how to retrieve the standings for all active competitions in the API.

Para buscar a classificação (/standings) precisamos de dois parâmetros: o ID da liga e a temporada. Como não sabemos de antemão quais ligas estão ativas, vamos buscar isso primeiro.

1. Buscar todas as ligas ativas / Get all active leagues

Uma chamada ao endpoint /leagues com current=true retorna apenas as temporadas ativas. Também verificamos o campo coverage.standings para filtrar apenas competições que possuem classificação.

const API_KEY = 'YOUR_API_KEY';
const BASE = 'https://football.api.insyde.one';

async function fetchApi(endpoint, params = {}) {
  params.key = API_KEY;
  const qs = new URLSearchParams(params).toString();
  const res = await fetch(`${BASE}/${endpoint}?${qs}`);
  return res.json();
}

// Get all active leagues
const leaguesData = await fetchApi('leagues', { current: 'true' });
console.log(`Total active leagues: ${leaguesData.results}`);

A API retorna as ligas com sua cobertura de dados / The API returns leagues with their data coverage:

{
  "get": "leagues",
  "parameters": { "current": "true" },
  "results": 900,
  "response": [
    {
      "league": {
        "id": 71,
        "name": "Serie A",
        "type": "League",
        "logo": "https://football.api.insyde.one/football/leagues/71.png"
      },
      "country": {
        "name": "Brazil",
        "code": "BR",
        "flag": "https://football.api.insyde.one/flags/br.svg"
      },
      "seasons": [
        {
          "year": 2025,
          "start": "2025-03-29",
          "end": "2025-12-07",
          "current": true,
          "coverage": {
            "fixtures": { "events": true, "lineups": true, ... },
            "standings": true,
            "players": true,
            "top_scorers": true,
            ...
          }
        }
      ]
    },
    ...
  ]
}

2. Filtrar ligas com classificação / Filter leagues with standings

Percorremos os resultados e mantemos apenas as competições onde coverage.standings é true.

const leaguesWithStandings = leaguesData.response
  .filter(({ seasons }) => {
    const current = seasons[0];
    return current.coverage.standings === true;
  })
  .map(({ league, seasons }) => ({
    league: league.id,
    name: league.name,
    season: seasons[0].year
  }));

console.log(`Leagues with standings: ${leaguesWithStandings.length}`);

O array leaguesWithStandings agora contém objetos como:

[
  { "league": 71, "name": "Serie A", "season": 2025 },
  { "league": 72, "name": "Serie B", "season": 2025 },
  { "league": 39, "name": "Premier League", "season": 2024 },
  ...
]

3. Buscar classificação de cada liga / Get standings for each league

Agora chamamos /standings para cada liga. Como temos muitas ligas, precisamos respeitar o rate limit adicionando um delay entre as chamadas.

function delay(ms) {
  return new Promise(r => setTimeout(r, ms));
}

async function getAllStandings(leagues) {
  const allStandings = [];

  for (let i = 0; i < leagues.length; i++) {
    const { league, season, name } = leagues[i];

    const data = await fetchApi('standings', { league, season });

    if (data.results > 0) {
      allStandings.push({
        league: name,
        season,
        standings: data.response[0].league.standings
      });
    }

    // Delay every 2 requests to respect rate limit
    if ((i + 1) % 2 === 0) {
      await delay(1000);
    }

    console.log(`  [${i + 1}/${leagues.length}] ${name} ${season} — ${data.results} results`);
  }

  return allStandings;
}

const standings = await getAllStandings(leaguesWithStandings);
console.log(`Total standings fetched: ${standings.length}`);

4. Resumo do fluxo / Flow summary

1. Chamar /leagues?current=true para obter todas as ligas ativas / Call /leagues?current=true to get all active leagues
2. Filtrar apenas as que possuem coverage.standings = true / Filter only those with coverage.standings = true
3. Para cada liga, chamar /standings?league=ID&season=YEAR / For each league, call /standings
4. Respeitar o rate limit com delays entre chamadas / Respect rate limits with delays between calls

5. Script completo / Complete script

const API_KEY = 'YOUR_API_KEY';
const BASE = 'https://football.api.insyde.one';

async function fetchApi(endpoint, params = {}) {
  params.key = API_KEY;
  const qs = new URLSearchParams(params).toString();
  const res = await fetch(`${BASE}/${endpoint}?${qs}`);
  return res.json();
}

function delay(ms) {
  return new Promise(r => setTimeout(r, ms));
}

async function main() {
  // 1. Get all active leagues
  const leaguesData = await fetchApi('leagues', { current: 'true' });
  console.log(`Active leagues: ${leaguesData.results}`);

  // 2. Filter leagues with standings coverage
  const targets = leaguesData.response
    .filter(({ seasons }) => seasons[0].coverage.standings === true)
    .map(({ league, seasons }) => ({
      league: league.id,
      name: league.name,
      season: seasons[0].year
    }));

  console.log(`Leagues with standings: ${targets.length}`);

  // 3. Fetch standings for each league
  for (let i = 0; i < targets.length; i++) {
    const { league, season, name } = targets[i];
    const data = await fetchApi('standings', { league, season });

    if (data.results > 0) {
      const table = data.response[0].league.standings[0];
      console.log(`\n${name} ${season}:`);
      table.slice(0, 5).forEach(row => {
        console.log(`  #${row.rank} ${row.team.name} — ${row.points} pts (${row.form})`);
      });
    }

    if ((i + 1) % 2 === 0) await delay(1000);
  }
}

main();

Saída esperada / Expected output:

Active leagues: 900
Leagues with standings: 620

Serie A 2025:
  #1 Flamengo — 25 pts (WWDWW)
  #2 Palmeiras — 23 pts (WDWWW)
  #3 Corinthians — 21 pts (WWWDL)
  #4 Botafogo — 20 pts (WDWWL)
  #5 São Paulo — 19 pts (DWWLW)

Premier League 2024:
  #1 Liverpool — 82 pts (WWWWW)
  ...

Back to Football API docs