Head to Head

GET https://api.sportsapipro.com/v1/football/games/h2h

{
  "game": {
    "id": 4477087,
    "sportId": 1,
    "competitionId": 23,
    "seasonNum": 11,
    "stageNum": 1,
    "groupNum": 0,
    "roundName": "Round",
    "stageName": "Semi Finals",
    "competitionDisplayName": "Supercoppa Italiana - Semi Finals",
    "startTime": "2025-12-19T19:00:00+00:00",
    "statusGroup": 4,
    "statusText": "After Penalties",
    "shortStatusText": "AP",
    "gameTimeAndStatusDisplayType": 1,
    "justEnded": false,
    "gameTime": 120,
    "gameTimeDisplay": "120'",
    "hasLineups": true,
    "hasMissingPlayers": false,
    "hasFieldPositions": true,
    "lineupsStatus": 2,
    "lineupsStatusText": "Confirmed",
    "hasTVNetworks": true,
    "winDescription": "Bologna won after penalties",
    "homeCompetitor": { /* Competitor Object */ },
    "awayCompetitor": { /* Competitor Object */ },
    "h2hGames": [ /* Array of H2H Game Objects */ ],
    "isHomeAwayInverted": false,
    "hasStats": true,
    "hasStandings": true,
    "hasBrackets": true,
    "hasPreviousMeetings": true,
    "hasRecentMatches": true,
    "winner": 1,
    "homeAwayTeamOrder": 1,
    "hasNews": true,
    "hasPointByPoint": false,
    "hasVideo": true
  },
  "bookmakers": [ /* Array of Bookmaker Objects */ ],
  "sports": [ /* Array of Sport Objects */ ],
  "countries": [ /* Array of Country Objects */ ],
  "competitions": [ /* Array of Competition Objects */ ]
}

const fixturesResponse = await fetch(
  "https://api.sportsapipro.com/v1/football/games/fixtures?competitions=9",
  { headers: { "x-api-key": "YOUR_API_KEY" } }
);
const fixtures = await fixturesResponse.json();

// Each game contains the IDs you need
const game = fixtures.games[0];
console.log({
  gameId: game.id,                    // e.g., 4609057
  matchupId: game.matchupId,          // e.g., "14-106-9"
  homeTeamId: game.homeCompetitor.id, // e.g., 14
  awayTeamId: game.awayCompetitor.id  // e.g., 106
});

const h2hResponse = await fetch(
  `https://api.sportsapipro.com/v1/football/games/h2h?gameId=${game.id}&matchupId=${game.matchupId}`,
  { headers: { "x-api-key": "YOUR_API_KEY" } }
);
const h2hData = await h2hResponse.json();

// Direct H2H matches are in h2hGames array
const directH2HMatches = h2hData.game.h2hGames;
console.log(`Found ${directH2HMatches.length} direct H2H matches`);

// Filter for completed matches only (statusGroup 4 = ended)
const completedH2H = directH2HMatches.filter(match => match.statusGroup === 4);
console.log(`${completedH2H.length} completed matches`);

// Recent matches for each team (against any opponent)
const homeTeamForm = h2hData.game.homeCompetitor.recentGames;
const awayTeamForm = h2hData.game.awayCompetitor.recentGames;

console.log(`Home team has ${homeTeamForm.length} recent matches`);
console.log(`Away team has ${awayTeamForm.length} recent matches`);

function calculateH2HRecord(h2hGames, homeTeamId, awayTeamId) {
  // Filter for completed matches only
  const completedMatches = h2hGames.filter(match => 
    match.statusGroup === 4 && match.scores?.length >= 2
  );
  
  let homeWins = 0, awayWins = 0, draws = 0;
  
  completedMatches.forEach(match => {
    if (match.winner === 1) {
      // Home team of THIS match won
      if (match.homeCompetitor.id === homeTeamId) homeWins++;
      else awayWins++;
    } else if (match.winner === 2) {
      // Away team of THIS match won
      if (match.awayCompetitor.id === homeTeamId) homeWins++;
      else awayWins++;
    } else {
      draws++;
    }
  });
  
  return { homeWins, awayWins, draws, total: completedMatches.length };
}

// Usage
const record = calculateH2HRecord(
  h2hData.game.h2hGames,
  h2hData.game.homeCompetitor.id,
  h2hData.game.awayCompetitor.id
);
console.log(`${record.homeWins} - ${record.draws} - ${record.awayWins}`);

function calculateForm(recentGames, teamId, matchCount = 5) {
  return recentGames.slice(0, matchCount).map(game => {
    const isHome = game.homeCompetitor?.id === teamId;
    const teamScore = isHome ? game.homeCompetitor?.score : game.awayCompetitor?.score;
    const oppScore = isHome ? game.awayCompetitor?.score : game.homeCompetitor?.score;
    
    if (teamScore > oppScore) return 'W';
    if (teamScore === oppScore) return 'D';
    return 'L';
  });
}

// Usage
const homeForm = calculateForm(
  h2hData.game.homeCompetitor.recentGames,
  h2hData.game.homeCompetitor.id
);
console.log(`Form: ${homeForm.join('')}`); // e.g., "WWDLW"

const h2hGames = h2hData.game.h2hGames;

// Upcoming matches between these teams (statusGroup 1 = Scheduled)
const upcomingH2H = h2hGames.filter(match => match.statusGroup === 1);

// Live matches between these teams (statusGroup 2 or 3 = In progress)
const liveH2H = h2hGames.filter(match => match.statusGroup === 2 || match.statusGroup === 3);

// Completed matches between these teams (statusGroup 4 = Ended)
const completedH2H = h2hGames.filter(match => match.statusGroup === 4);

console.log(`${upcomingH2H.length} upcoming, ${liveH2H.length} live, ${completedH2H.length} completed`);

function calculateH2HGoals(h2hGames, teamId) {
  const completedMatches = h2hGames.filter(m => m.statusGroup === 4 && m.scores);
  
  let goalsFor = 0, goalsAgainst = 0;
  
  completedMatches.forEach(match => {
    const isHome = match.homeCompetitor.id === teamId;
    goalsFor += isHome ? (match.scores[0] || 0) : (match.scores[1] || 0);
    goalsAgainst += isHome ? (match.scores[1] || 0) : (match.scores[0] || 0);
  });
  
  return { goalsFor, goalsAgainst, matches: completedMatches.length };
}

function getRecentH2H(h2hGames, count = 10) {
  // Filter completed games, sort by startTime descending
  return h2hGames
    .filter(match => match.statusGroup === 4)
    .sort((a, b) => new Date(b.startTime) - new Date(a.startTime))
    .slice(0, count);
}

// Get last 10 H2H meetings
const recentH2H = getRecentH2H(h2hData.game.h2hGames, 10);

function getH2HByCompetition(h2hGames, competitionId) {
  return h2hGames.filter(match => match.competitionId === competitionId);
}

// Get only Serie A H2H matches
const serieAH2H = getH2HByCompetition(h2hData.game.h2hGames, 9);

const h2hGames = h2hData.game.h2hGames || [];
const completedH2H = h2hGames.filter(m => m.statusGroup === 4);

if (h2hGames.length === 0) {
  showMessage("These teams have never met");
} else if (completedH2H.length === 0) {
  showMessage("First competitive meeting between these teams");
} else {
  displayH2HHistory(completedH2H);
}

const h2hCache = new Map();
const CACHE_TTL = 60 * 60 * 1000; // 1 hour

async function getCachedH2H(gameId, matchupId, apiKey) {
  const cacheKey = `${gameId}-${matchupId}`;
  
  if (h2hCache.has(cacheKey)) {
    const { data, timestamp } = h2hCache.get(cacheKey);
    if (Date.now() - timestamp < CACHE_TTL) return data;
  }
  
  const response = await fetch(
    `https://api.sportsapipro.com/v1/football/games/h2h?gameId=${gameId}&matchupId=${matchupId}`,
    { headers: { "x-api-key": apiKey } }
  );
  const data = await response.json();
  
  h2hCache.set(cacheKey, { data, timestamp: Date.now() });
  return data;
}

class H2HService {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.sportsapipro.com/v1/football';
  }

  async getH2H(gameId, matchupId) {
    const response = await fetch(
      `${this.baseUrl}/games/h2h?gameId=${gameId}&matchupId=${matchupId}`,
      { headers: { 'x-api-key': this.apiKey } }
    );
    return response.json();
  }

  analyzeH2H(h2hData) {
    const homeTeam = h2hData.game.homeCompetitor;
    const awayTeam = h2hData.game.awayCompetitor;
    const h2hGames = h2hData.game.h2hGames || [];
    
    // Completed H2H matches
    const completedH2H = h2hGames.filter(m => m.statusGroup === 4);
    
    // Upcoming H2H matches
    const upcomingH2H = h2hGames.filter(m => m.statusGroup === 2);
    
    // Calculate H2H record
    const record = this.calculateRecord(completedH2H, homeTeam.id);
    
    // Calculate goals
    const homeGoals = this.calculateGoals(completedH2H, homeTeam.id);
    const awayGoals = this.calculateGoals(completedH2H, awayTeam.id);
    
    // Calculate form for each team
    const homeForm = this.calculateForm(homeTeam.recentGames, homeTeam.id);
    const awayForm = this.calculateForm(awayTeam.recentGames, awayTeam.id);
    
    return {
      homeTeam: homeTeam.name,
      awayTeam: awayTeam.name,
      h2hRecord: record,
      totalMeetings: completedH2H.length,
      upcomingMeetings: upcomingH2H.length,
      homeGoals,
      awayGoals,
      homeForm,
      awayForm,
      recentH2H: completedH2H.slice(0, 5),
      allH2H: h2hGames
    };
  }

  calculateRecord(matches, homeTeamId) {
    let homeWins = 0, awayWins = 0, draws = 0;
    
    matches.forEach(match => {
      if (match.winner === 1) {
        match.homeCompetitor.id === homeTeamId ? homeWins++ : awayWins++;
      } else if (match.winner === 2) {
        match.awayCompetitor.id === homeTeamId ? homeWins++ : awayWins++;
      } else {
        draws++;
      }
    });
    
    return { homeWins, awayWins, draws };
  }

  calculateGoals(matches, teamId) {
    let goalsFor = 0, goalsAgainst = 0;
    
    matches.forEach(match => {
      if (!match.scores) return;
      const isHome = match.homeCompetitor.id === teamId;
      goalsFor += isHome ? match.scores[0] : match.scores[1];
      goalsAgainst += isHome ? match.scores[1] : match.scores[0];
    });
    
    return { goalsFor, goalsAgainst };
  }

  calculateForm(recentGames, teamId) {
    return recentGames.slice(0, 5).map(game => {
      const isHome = game.homeCompetitor?.id === teamId;
      const teamScore = isHome ? game.homeCompetitor?.score : game.awayCompetitor?.score;
      const oppScore = isHome ? game.awayCompetitor?.score : game.homeCompetitor?.score;
      
      if (teamScore > oppScore) return 'W';
      if (teamScore === oppScore) return 'D';
      return 'L';
    }).join('');
  }
}

// Usage
const h2hService = new H2HService('YOUR_API_KEY');
const h2hData = await h2hService.getH2H(4477087, '224-245-23');
const analysis = h2hService.analyzeH2H(h2hData);

console.log(analysis);
// {
//   homeTeam: "Bologna",
//   awayTeam: "Inter Milan",
//   h2hRecord: { homeWins: 5, awayWins: 12, draws: 3 },
//   totalMeetings: 20,
//   upcomingMeetings: 1,
//   homeGoals: { goalsFor: 18, goalsAgainst: 34 },
//   awayGoals: { goalsFor: 34, goalsAgainst: 18 },
//   homeForm: "LWDWW",
//   awayForm: "WWWLW",
//   recentH2H: [...],
//   allH2H: [...]
// }