World Cup 2026 Qualified Teams: How to Track Teams & Squads via API

What you’ll learn

This guide covers everything you need to know about accessing World Cup 2026 team data:
– Retrieving all 48 qualified teams for the tournament
– Accessing complete squad lists with player details
– Getting team statistics and performance metrics
– Tracking squad changes and player transfers.
– Understanding team metadata (venues, coaches, country info)
– Optimising API calls for efficient data retrieval.

Prerequisites

Before you begin, ensure you have:

1. Sportmonks API Account: Sign up at my.sportmonks.com
2. API Token: Your unique authentication token
3. World Cup 2026 Coverage: Verify your plan includes Season ID 26618
4. Base URL: https://api.sportmonks.com/v3/football

Understanding the World Cup 2026 teams API

The Sportmonks World Cup 2026 teams API provides comprehensive access to all qualified teams through a structured endpoint system. Let’s explore how to work with this team data API.

Key identifiers

– Season ID: 26618 (FIFA World Cup 2026)
– League ID: The World Cup league ID (check via seasons endpoint)
– Team IDs: Unique identifier for each participating nation

Step 1: Getting all World Cup 2026 qualified teams

Method 1: Via season endpoint (recommended)

The most reliable way to get all World Cup-qualified teams is through the season endpoint, with the teams include:

GET https://api.sportmonks.com/v3/football/seasons/26618
 ?api_token=YOUR_TOKEN
 &include=teams

What this returns

– Season information (name, start/end dates, is_current status)
– Complete array of all 48 participating teams
– Basic team data (ID, name, country, image, founded year)

Response structure

{
 "data": {
   "id": 26618,
   "sport_id": 1,
   "league_id": 732,
   "name": "2026",
   "finished": false,
   "pending": false,
   "is_current": true,
   "starting_at": "2026-06-11",
   "ending_at": "2026-07-19",
   "teams": [
     {
       "id": 18644,
       "sport_id": 1,
       "country_id": 1072,
       "venue_id": 219736,
       "gender": "male",
       "name": "Argentina",
       "short_code": "ARG",
       "image_path": "https://cdn.sportmonks.com/images/soccer/teams/...",
       "founded": 1893,
       "type": "national",
       "placeholder": false,
       "last_played_at": "2025-03-25 20:00:00"
     },
     {
       "id": 18704,
       "name": "Brazil",
       "short_code": "BRA"
     }
     // ... all 48 teams
   ]
 }
}

Include depth: The teams include is 1 level deep, well within the allowed limit.

Method 2: Via teams endpoint with season filter

Alternatively, retrieve teams directly from the teams endpoint:

GET https://api.sportmonks.com/v3/football/teams/seasons/26618
 ?api_token=YOUR_TOKEN

What this returns

– An array of all teams participating in the World Cup 2026
– Paginated results (default 25 teams per page)

Pagination

GET https://api.sportmonks.com/v3/football/teams/seasons/26618
 ?api_token=YOUR_TOKEN
 &per_page=50
 &page=1

Use per_page=50 (maximum) to retrieve all 48 teams in a single request.

Step 2: Getting team squads (squads API)

The squads API is your gateway to accessing complete player rosters for each World Cup team.

Getting squad for a specific team

To get the complete squad for a single team:

GET https://api.sportmonks.com/v3/football/squads/seasons/26618/teams/{team_id}
 ?api_token=YOUR_TOKEN
 &include=player.position

Example (Brazil – Team ID: 18704)

GET https://api.sportmonks.com/v3/football/squads/seasons/26618/teams/18704
 ?api_token=YOUR_TOKEN
 &include=player.position

What this returns

– Squad entries for the season
– Player IDs
– Player profiles (name, display_name, image, date of birth, height, weight)
– Position information via the player object

Response structure

{
 "data": [
   {
     "id": 1864719771,
     "player_id": 129820,
     "team_id": 18704,
     "season_id": 26618,
     "has_values": false,
     "position_id": null,
     "jersey_number": null,
     "player": {
       "id": 129820,
       "sport_id": 1,
       "country_id": 5,
       "nationality_id": 5,
       "city_id": 63660,
       "position_id": 24,
       "detailed_position_id": 24,
       "type_id": 24,
       "common_name": "A. Becker",
       "firstname": "Alisson Ramsu00e9s",
       "lastname": "Becker",
       "name": "Alisson Ramsu00e9s Becker",
       "display_name": "Alissonu00a0",
       "image_path": "https://cdn.sportmonks.com/images/soccer/players/28/129820.png",
       "height": 193,
       "weight": 91,
       "date_of_birth": "1992-10-02",
       "gender": "male",
       "position": {
         "id": 24,
         "name": "Goalkeeper",
         "code": "goalkeeper",
         "developer_name": "GOALKEEPER",
         "model_type": "position",
         "stat_group": null
       }
     }
   },
   // ... more squad members
 ]
}

Important fields

– has_values: Boolean indicating if statistics exist for this player in the season
– position_id: Often null at squad level – use player.position_id instead
– jersey_number: Often null at squad level until officially announced
– player.position_id: Position type (1/24=Goalkeeper, 2/25=Defender, 3/26=Midfielder, 4/27=Attacker)

Include depth: This endpoint allows 2 nested includes.

– player is 1 level
– player.position is 2 levels

Alternative: Current Squad by Team ID

To get the current domestic squad (all active seasons):

GET https://api.sportmonks.com/v3/football/squads/teams/{team_id}

 ?api_token=YOUR_TOKEN

 &include=player.position

Include depth: This endpoint allows 4 nested includes.

Available includes:
– team (1 level)
– player (1 level)
– position (1 level)
– detailedPosition (1 level)
– transfer (1 level)
– player.position (2 levels)

Step 3: Enriching team data

Getting team statistics

Add team statistics to understand performance metrics:

GET https://api.sportmonks.com/v3/football/teams/seasons/26618
 ?api_token=YOUR_TOKEN
 &include=statistics

Available team statistics

– Goals scored/conceded
– Clean sheets
– Win/draw/loss record.
– Average possession
– Shot accuracy
– Cards received
– And 50+ more metrics

Getting team venue information

Include venue data to know where teams play:

GET https://api.sportmonks.com/v3/football/teams/seasons/26618
 ?api_token=YOUR_TOKEN
 &include=venue

Venue data includes

– Stadium name
– City and country
– Capacity
– Surface type
– Image
– Coordinates

Getting team coaches

Track coaching staff for each team:

GET https://api.sportmonks.com/v3/football/teams/{team_id}
 ?api_token=YOUR_TOKEN
 &include=coaches

Coach information

– Name and nationality
– Start/end dates
– Image
– Previous teams

Complete team profile

For a comprehensive team profile combining multiple data points:

GET https://api.sportmonks.com/v3/football/teams/{team_id}
 ?api_token=YOUR_TOKEN
 &include=country;venue;coaches

Include depth: Maximum 3 nested includes on the teams endpoint.

Step 4: Working with squad data

Filtering Squad players by position

After retrieving the squad, filter players by position in your application code:

// Fetch squad
const response = await fetch(
 `https://api.sportmonks.com/v3/football/squads/seasons/26618/teams/${teamId}` +
 `?api_token=${token}&include=player.position`
);

const squadData = await response.json();

// Filter by position
const goalkeepers = squadData.data.filter(p => p.position_id === 1);
const defenders = squadData.data.filter(p =>
 p.position_id === 2 || p.position_id === 25
);
const midfielders = squadData.data.filter(p =>
 p.position_id === 3 || p.position_id === 26
);
const attackers = squadData.data.filter(p =>
 p.position_id === 4 || p.position_id === 27
);

Position IDs

– 1: Goalkeeper
– 2 or 25: Defender
– 3 or 26: Midfielder
– 4 or 27: Attacker

Getting active squad members only

Filter for players currently in the squad:

const activeSquad = squadData.data.filter(p => p.in_squad === true);

Identifying team captains

Find the team captain:

const captain = squadData.data.find(p => p.captain === true);

Step 5: Tracking multiple teams efficiently

Batch approach for all 48 teams

To build a complete database of all World Cup teams and squads:

async function getAllWorldCupSquads() {
 const season_id = 26618;
 const allSquads = [];
 
 // Step 1: Get all teams
 const teamsResponse = await fetch(
   `https://api.sportmonks.com/v3/football/teams/seasons/${season_id}` +
   `?api_token=${token}&per_page=50`
 );
 
 const teamsData = await teamsResponse.json();
 const teams = teamsData.data;
 
 console.log(`Found ${teams.length} World Cup teams`);
 
 // Step 2: Get squad for each team
 for (const team of teams) {
   try {
     const squadResponse = await fetch(
       `https://api.sportmonks.com/v3/football/squads/seasons/${season_id}/teams/${team.id}` +
       `?api_token=${token}&include=player.position`
     );
     
     const squadData = await squadResponse.json();
     
     allSquads.push({
       team_id: team.id,
       team_name: team.name,
       team_country: team.country_id,
       squad: squadData.data
     });
     
     // Respect rate limits - wait 200ms between requests
     await new Promise(resolve => setTimeout(resolve, 200));
     
   } catch (error) {
     console.error(`Error fetching squad for ${team.name}:`, error);
   }
 }
 
 return allSquads;
}

Rate limit management

– Standard limit: 3,000 requests per entity per hour
– For 48 teams: ~1 request per team = 48 requests total
– Add a 200ms delay between requests to be safe.

Step 6: Field selection for optimisation

Use the select parameter to retrieve only the fields you need:

Optimised team request

GET https://api.sportmonks.com/v3/football/teams/seasons/26618
 ?api_token=YOUR_TOKEN
 &select=id,name,short_code,country_id,image_path

This reduces response size significantly when you only need basic team info.

Optimised squad request

GET https://api.sportmonks.com/v3/football/squads/seasons/26618/teams/{team_id}
 ?api_token=YOUR_TOKEN
 &select=player_id,position_id,jersey_number,captain,in_squad
 &include=player

Note: When using select, you must still explicitly include relationships you need via the include parameter.

Step 7: Monitoring squad changes

Track squad updates over time

World Cup squads may change due to injuries or tactical decisions. Track changes by:

1. Storing initial squad data when first retrieved
2. Periodically re-fetching (e.g., daily during qualification, weekly during tournament preparation)
3. Comparing in_squad status for each player
4. Checking for new players added to the squad

function detectSquadChanges(oldSquad, newSquad) {
 const changes = {
   added: [],
   removed: [],
   statusChanged: []
 };
 
 // Create maps for easier comparison
 const oldMap = new Map(oldSquad.map(p => [p.player_id, p]));
 const newMap = new Map(newSquad.map(p => [p.player_id, p]));
 
 // Find added players
 newSquad.forEach(player => {
   if (!oldMap.has(player.player_id)) {
     changes.added.push(player);
   }
 });
 
 // Find removed players and status changes
 oldSquad.forEach(player => {
   const newPlayer = newMap.get(player.player_id);
   
   if (!newPlayer) {
     changes.removed.push(player);
   } else if (player.in_squad !== newPlayer.in_squad) {
     changes.statusChanged.push({
       player: newPlayer,
       oldStatus: player.in_squad,
       newStatus: newPlayer.in_squad
     });
   }
 });
 
 return changes;
}

Step 8: Understanding team types

The type field in team data indicates the team category:

Team types:

– “national”: National teams (all World Cup teams)
– “domestic”: Club teams (not applicable for World Cup)

Filter specifically for national teams:

const nationalTeams = teams.filter(team => team.type === "national");

Step 9: Working with team countries

Getting country information

Each team has a country_id. To get full country details:

GET https://api.sportmonks.com/v3/football/teams/{team_id}
 ?api_token=YOUR_TOKEN
 &include=country

Country data includes

– Country name
– Continent
– FIFA ranking (if applicable)
– Country image/flag
– Official name

Grouping teams by confederation

function groupByConfederation(teams) {
 const confederations = {
   UEFA: [], // Europe
   CONMEBOL: [], // South America
   CAF: [], // Africa
   AFC: [], // Asia
   CONCACAF: [], // North/Central America & Caribbean
   OFC: [] // Oceania
 };
 
 teams.forEach(team => {
   // Map country_id to confederation
   const confederation = getConfederation(team.country_id);
   if (confederation && confederations[confederation]) {
     confederations[confederation].push(team);
   }
 });
 
 return confederations;
}

Step 10: Complete implementation example

Here’s a complete workflow for building a World Cup teams page:

async function buildWorldCupTeamsPage() {
 const season_id = 26618;
 const token = 'YOUR_TOKEN';
 
 try {
   // 1. Fetch season with all teams
   console.log('Fetching World Cup 2026 teams...');
   const seasonResponse = await fetch(
     `https://api.sportmonks.com/v3/football/seasons/${season_id}` +
     `?api_token=${token}&include=teams`
   );
   
   const seasonData = await seasonResponse.json();
   const teams = seasonData.data.teams;
   
   console.log(`Found ${teams.length} qualified teams`);
   
   // 2. Fetch detailed data for featured teams (e.g., defending champion)
   const featuredTeams = ['Argentina', 'France', 'Brazil'];
   const teamDetails = [];
   
   for (const teamName of featuredTeams) {
     const team = teams.find(t => t.name === teamName);
     if (!team) continue;
     
     // Get full team profile with squad
     const detailResponse = await fetch(
       `https://api.sportmonks.com/v3/football/squads/seasons/${season_id}/teams/${team.id}` +
       `?api_token=${token}&include=player.position`
     );
     
     const squadData = await detailResponse.json();
     
     teamDetails.push({
       ...team,
       squad: squadData.data
     });
     
     await new Promise(resolve => setTimeout(resolve, 300));
   }
   
   // 3. Return structured data
   return {
     tournament: {
       name: seasonData.data.name,
       startDate: seasonData.data.starting_at,
       endDate: seasonData.data.ending_at
     },
     allTeams: teams,
     featuredTeams: teamDetails,
     statistics: {
       totalTeams: teams.length,
       confederations: groupByConfederation(teams)
     }
   };
   
 } catch (error) {
   console.error('Error building World Cup teams page:', error);
   throw error;
 }
}

// Usage
buildWorldCupTeamsPage().then(data => {
 console.log('World Cup 2026 Teams Page Data:', data);
 renderTeamsPage(data);
});

Best practices summary

✅ DO

– Cache team and squad data – This data doesn’t change frequently.
– Use per_page=50 for the teams endpoint to fetch all 48 teams in a single request.
– Respect rate limits: add delays between batch requests.
– Check in_squad status to filter active players.
– Use the select parameter to optimise the response size.
– Store team IDs for quick lookups
– Update squad data periodically (weekly during preparation, daily during the tournament)
– Handle pagination properly using the has_more parameter.
– Verify include depth limits before constructing requests.

❌ DON’T

– Don’t exceed nested include limits (2 levels on squads/seasons endpoint)
– Don’t poll squad data in real-time – it doesn’t change that frequently.
– Don’t make sequential requests without delays – respect rate limits|
– Don’t ignore the type field – filter for “national” teams only.
– Don’t forget error handling – API calls can fail.
– Don’t request unnecessary includes – keep requests lean.
– Don’t assume all 48 teams will always be available – handle edge cases.

Common use cases

Use case 1: Team selector for fantasy game

async function getTeamsForFantasySelector() {
 const response = await fetch(
   `https://api.sportmonks.com/v3/football/teams/seasons/26618` +
   `?api_token=${token}` +
   `&select=id,name,short_code,image_path` +
   `&per_page=50`
 );
 
 const data = await response.json();
 
 return data.data.map(team => ({
   value: team.id,
   label: team.name,
   code: team.short_code,
   logo: team.image_path
 }));
}

Use case 2: Squad statistics dashboard

async function getSquadStatistics(teamId) {
 const response = await fetch(
   `https://api.sportmonks.com/v3/football/squads/seasons/26618/teams/${teamId}` +
   `?api_token=${token}&include=player.position`
 );
 
 const data = await response.json();
 const squad = data.data.filter(p => p.in_squad);
 
 return {
   totalPlayers: squad.length,
   goalkeepers: squad.filter(p => p.position_id === 1).length,
   defenders: squad.filter(p => [2, 25].includes(p.position_id)).length,
   midfielders: squad.filter(p => [3, 26].includes(p.position_id)).length,
   attackers: squad.filter(p => [4, 27].includes(p.position_id)).length,
   captain: squad.find(p => p.captain)?.player.name || 'TBD',
   averageAge: calculateAverageAge(squad)
 };
}

function calculateAverageAge(squad) {
 const ages = squad.map(p => {
   const birthDate = new Date(p.player.date_of_birth);
   const today = new Date();
   return today.getFullYear() - birthDate.getFullYear();
 });
 
 return (ages.reduce((sum, age) => sum + age, 0) / ages.length).toFixed(1);
}

Use case 3: Team comparison tool

async function compareTeams(teamId1, teamId2) {
 const [squad1, squad2] = await Promise.all([
   fetch(`https://api.sportmonks.com/v3/football/squads/seasons/26618/teams/${teamId1}` +
         `?api_token=${token}&include=player`).then(r => r.json()),
   fetch(`https://api.sportmonks.com/v3/football/squads/seasons/26618/teams/${teamId2}` +
         `?api_token=${token}&include=player`).then(r => r.json())
 ]);
 
 return {
   team1: {
     squadSize: squad1.data.length,
     avgHeight: calculateAverageHeight(squad1.data),
     avgAge: calculateAverageAge(squad1.data)
   },
   team2: {
     squadSize: squad2.data.length,
     avgHeight: calculateAverageHeight(squad2.data),
     avgAge: calculateAverageAge(squad2.data)
   }
 };
}

function calculateAverageHeight(squad) {
 const heights = squad.map(p => p.player.height).filter(h => h);
 return (heights.reduce((sum, h) => sum + h, 0) / heights.length).toFixed(1);
}

Troubleshooting common issues

Issue 1: “No results found” for World Cup season

Problem: Empty response when querying season 26618

Solution: Verify your subscription includes World Cup 2026 coverage. Check with:

GET https://api.sportmonks.com/v3/football/seasons/26618
 ?api_token=YOUR_TOKEN

If you get an error, contact [email protected] to add World Cup coverage to your plan.

Issue 2: “Maximum nested includes exceeded”

Problem: Error when using too many nested includes

Solution: Check the include depth limit for each endpoint:
– /squads/seasons/{id}/teams/{id}: 2 nested includes maximum
– /squads/teams/{id}: 4 nested includes maximum
– /teams/{id}: 3 nested includes maximum

Break complex requests into multiple calls if needed.

Issue 3: Missing squad data

Problem: Squad endpoint returns an empty array

Solution:

1. Verify the team ID is correct.
2. Check if the team has officially announced its squad for the World Cup 2026
3. Squads may not be available until closer to the tournament.
4. Use the current squad endpoint /squads/teams/{id} as an alternative.

Issue 4: Rate Limit Errors (429)

Problem: “Rate limit exceeded” error

Solution

– Check the x-ratelimit-remaining header in responses.
– Implement delays between requests (200-300ms recommended)
– Cache responses to reduce API calls
– Upgrade plan if you consistently hit limits

Conclusion

The Sportmonks World Cup 2026 teams API and squads API provide comprehensive access to all qualified teams and their player rosters through well-structured endpoints. By following this guide, you now know how to:

• Retrieve all 48 World Cup 2026 qualified teams efficiently.
• Access complete squad lists with player details and positions
• Optimise API requests with proper includes and field selection
• Track squad changes and monitor team updates.
• Build real-world applications like team directories, fantasy games, and statistics dashboards.

The team data API follows RESTful principles with clear endpoint structures, making it straightforward to integrate World Cup team and squad data into any application. Remember to respect rate limits, cache appropriately, and always verify include depth limits before constructing complex queries.

Additional resources

– Full API Documentation: docs.sportmonks.com/v3
– Teams Endpoint Reference: docs.sportmonks.com/v3/endpoints-and-entities/endpoints/teams
– Squads Endpoint Reference: docs.sportmonks.com/v3/endpoints-and-entities/endpoints/team-squads
– ID Finder Tool: my.sportmonks.com/resources/id-finder
– Postman Collection: postman.sportmonks.com
– Support: [email protected]

Ready to start tracking World Cup 2026 teams? Sign up for Sportmonks and get instant access to comprehensive team and squad data for all 48 qualified nations!