- What metrics are important for evaluating a forward’s effectiveness in football
- What data about forwards can be obtained through the sports statistics API
- How to calculate xG, xA, and other goal metrics for a forward through the API
- How to analyze a forward’s shots, positions, and actions on the field using the API
- What advanced metrics for forwards are available in popular sports event APIs
- How to automate the calculation of forward metrics based on API data
What metrics are important for evaluating a forward’s effectiveness in football
Evaluating a forward has long gone beyond simple goal statistics. In modern analytics, three blocks of indicators are important: effectiveness, quality of chances, and involvement in the game. Basic metrics include goals, assists, shots on goal, shots on target, and the share of goals without penalties. They help to understand how consistently a player finishes attacks. Additionally, the conversion rate of shots, the share of shots from inside the box, and how often a forward finishes attacks after key passes from teammates are analyzed.
The context of the quality of chances is no less important. Here, expected goals (xG) and expected assists (xA) metrics, the conversion rate of «big chances,» as well as the number of touches in the box, dribbles, and duels won in the final third help. According to the matchStatistics object in the responses from the Sport Events API, one can assess how much the team as a whole creates chances (totalShotsOnGoal, totalShotsInsideBox, bigChanceCreated, bigChanceScored, touchesInOppBox), and then overlay this on the individual numbers of the player obtained from their personal statistics in the lineup (lineup.players.statistics).
The third layer is sustainability and usefulness over distance: shots and goals per 90 minutes, contribution to pressing, number of losses and offsides, participation in combinations leading to shots. These metrics allow distinguishing a forward who scored due to a short successful streak from a player with a consistently high level of play. The source of such data is specialized solutions based on the Sport Events API: through regular requests to the endpoints /v2/football/matches and /v2/football/matches/{matchId}, you automatically collect match statistics, filter it by the desired player, and build your advanced models for evaluating the effectiveness of forwards.
// Пример: запрос деталей матча и базовой статистики атакующей команды
fetch('https://api.api-sport.ru/v2/football/matches/14570728', {
headers: {
'Authorization': 'ВАШ_API_КЛЮЧ'
}
})
.then(r => r.json())
.then(match => {
const stats = match.matchStatistics.find(s => s.period === 'ALL');
const shotsGroup = stats.groups.find(g => g.groupName === 'Shots');
const attackGroup = stats.groups.find(g => g.groupName === 'Attack');
// Пример базовых метрик для оценки атакующей мощи команды
const totalShots = shotsGroup.statisticsItems.find(i => i.key === 'totalShotsOnGoal');
const shotsInsideBox = shotsGroup.statisticsItems.find(i => i.key === 'totalShotsInsideBox');
const bigChances = attackGroup.statisticsItems.find(i => i.key === 'bigChanceCreated');
console.log('Всего ударов:', totalShots.homeValue, totalShots.awayValue);
console.log('Удары из штрафной:', shotsInsideBox.homeValue, shotsInsideBox.awayValue);
console.log('Создано больших шансов:', bigChances.homeValue, bigChances.awayValue);
});
What data about forwards can be obtained through the sports statistics API
Through the Sport Events API, which underlies the service Sports events API, You receive both profile data about forwards and their game statistics. The endpoint /v2/football/players returns a list of players with key information: name, country, date of birth, height, preferred foot, position (including F for forwards), number, contract duration, and estimated market value (proposedMarketValueEUR). This data allows you to segment players by age, anthropometry, and style, selecting the necessary profiles for the club’s game model or scouting tasks.
For detailed analysis of forwards’ performances, you combine player data with information about teams and matches. The endpoint /v2/football/teams returns the team lineup, where each player has a statistics object with parameters for a specific match: minutes on the field, goals, assists, shots, shots on target, key passes, dribbles, duels, and other metrics. In conjunction with match data from /v2/football/matches and /v2/football/matches/{matchId}, you get the full context: against which opponent the forward played, in which tournament, and under what score he converted chances.
Thanks to this API, you can build custom data showcases for forwards: a top scorers ranking considering xG, lists of undervalued forwards with a high number of touches in the penalty area and shots on goal, and player selection for a specific championship by age and style. All data is provided in a convenient JSON format and easily integrates into the club’s internal CRM, analytical dashboards, or odds modeling systems. The connection takes just a few minutes, and the access key can be obtained in the API personal account..
// Пример: получаем всех игроков команды и фильтруем только нападающих
const TEAM_ID = 195801;
fetch(`https://api.api-sport.ru/v2/football/players?team_id=${TEAM_ID}`, {
headers: {
'Authorization': 'ВАШ_API_КЛЮЧ'
}
})
.then(r => r.json())
.then(data => {
const forwards = data.players.filter(p => p.position === 'F');
forwards.forEach(player => {
console.log(`${player.name} (${player.country.name})`);
console.log('Возраст (timestamp):', player.dateOfBirthTimestamp);
console.log('Рабочая нога:', player.preferredFoot);
console.log('Рыночная стоимость, €:', player.proposedMarketValueEUR);
console.log('-------');
});
});
How to calculate xG, xA, and other goal metrics for a forward through the API
Expected goals (xG) and expected assists (xA) metrics allow you to evaluate not only the fact of scoring a goal but also the quality of created chances. In the classical approach, xG is calculated as the probability that a specific shot will become a goal, based on the characteristics of the episode: distance to the goal, angle, type of shot, situation (set piece, open play), pressure from defenders, etc. xA values reflect the probability that a pass will lead to a shot with a certain xG. These approaches are widely recognized in professional football analytics and are actively used by clubs and betting companies.
The Sport Events API does not impose a specific xG/xA model but provides raw data for its construction. From the liveEvents objects (endpoint /v2/football/matches/{matchId}/events), you get a sequence of events: goals, penalties, substitutions, and other key moments, to which you can link the shooter and the assister. Additionally, match statistics from matchStatistics provide aggregated features on shots, «big chances,» touches in the penalty area, and attack structure. On this basis, you train your own xG/xA model or use ready-made empirical coefficients (for example, typical studies show that an average shot from the penalty area has a higher expected xG than a long-range shot; the exact value depends on your model and sample).
In practice, it often starts with a simplified assessment: assigning average xG weights to shots from different zones, while for xA, a combination of assists and created «big chances» is used. With the Sport Events API, you can save the context of the match, opponent, tournament, and bookmaker odds dynamics (oddsBase field) for each shot by the forward. This allows you to compare the actual and expected performance of the forward with market expectations and find overvalued or undervalued players for betting, fantasy, or transfer analytics.
// Упрощённый пример расчёта xG по агрегированным данным команды
// В реальном проекте модель xG обучают на массиве эпизодов, здесь только демонстрация идеи
function estimateTeamXG(shotsInsideBox, shotsOutsideBox) {
const xGInside = 0.15; // пример усреднённого веса, зависит от вашей модели
const xGOutside = 0.04; // пример усреднённого веса, зависит от вашей модели
return shotsInsideBox * xGInside + shotsOutsideBox * xGOutside;
}
fetch('https://api.api-sport.ru/v2/football/matches/14570728', {
headers: { 'Authorization': 'ВАШ_API_КЛЮЧ' }
})
.then(r => r.json())
.then(match => {
const stats = match.matchStatistics.find(s => s.period === 'ALL');
const shotsGroup = stats.groups.find(g => g.groupName === 'Shots');
const insideItem = shotsGroup.statisticsItems.find(i => i.key === 'totalShotsInsideBox');
const outsideItem = shotsGroup.statisticsItems.find(i => i.key === 'totalShotsOutsideBox');
const homeXG = estimateTeamXG(insideItem.homeValue, outsideItem.homeValue);
const awayXG = estimateTeamXG(insideItem.awayValue, outsideItem.awayValue);
console.log('Оценочный xG хозяев:', homeXG.toFixed(2));
console.log('Оценочный xG гостей:', awayXG.toFixed(2));
});
How to analyze a forward’s shots, positions, and actions on the field using the API
A deep analysis of a forward’s game begins with analyzing his actions during the match: shots, movements, participation in possession phases, and pressing. Through the endpoint /v2/football/matches/{matchId}/events, you get a chronology of key events: goals, penalties, substitutions, cards, added time fixation, and other moments. By linking the player ID (player.id) from the events with player objects in the lineup (lineup.players), you can reconstruct the forward’s participation map in important episodes and assess his impact on the team’s game.
Aggregated match statistics help to complement the picture with qualitative indicators. In the matchStatistics object, there are groups Shots and Attack, which contain data on total shots, shots on target, shots from the penalty area and outside it, «big chances,» touches in the penalty area (touchesInOppBox), offsides, duels won, and successful dribbles. By comparing them with the minutes the forward spent on the field, you calculate shots and touches in the penalty area per 90 minutes, loss and offside frequency, as well as dribbling efficiency. These data can then be easily visualized in the form of graphs, heat maps, and dashboards for the coaching staff or analytical department.
In the future, the emergence of WebSocket connection in Sport Events API will allow translating such analysis in real time: receiving events immediately during the match, automatically updating the shot map, as well as embedding proprietary AI models on top of the data to recognize attacking movement patterns and predict moments. Already, REST endpoints provide everything necessary for building complex tracking systems and post-match analytics that summarize data across dozens of matches and seasons for each attacker.
// Пример: анализируем события матча и отбираем голы конкретного нападающего
const MATCH_ID = 14570728;
const FORWARD_ID = 123456; // ID нападающего из списка игроков
fetch(`https://api.api-sport.ru/v2/football/matches/${MATCH_ID}/events`, {
headers: { 'Authorization': 'ВАШ_API_КЛЮЧ' }
})
.then(r => r.json())
.then(data => {
const goals = data.events.filter(e => e.type === 'goal' && e.player && e.player.id === FORWARD_ID);
goals.forEach(goal => {
console.log(`Гол на ${goal.time}-й минуте, счёт ${goal.homeScore}:${goal.awayScore}`);
console.log('Команда:', goal.team === 'home' ? 'Хозяева' : 'Гости');
});
});
What advanced metrics for forwards are available in popular sports event APIs
In addition to basic statistics of goals and shots, professional sports event APIs offer a wide range of advanced metrics that are particularly important for evaluating attackers. These include touches in the penalty area, the share of shots from dangerous zones, participation in the final and penultimate phases of attack, successful dribbles in the final third, the share of duels won, as well as the engagement rate in progressive attacks. Within the Sport Events API, some of these metrics are already selected directly from matchStatistics: touchesInOppBox, finalThirdEntries, accurateCross, dribblesPercentage, duelWonPercent, and other indicators reflecting the quality and volume of actions in the attacking phase.
Based on these, it is easy to build composite indices. For example, the attack participation index can take into account touches in the penalty area, dribbles, entries into the final third (finalThirdEntries), and passing accuracy in the attacking zone. The penalty area assertiveness index combines shots from the penalty area, the percentage of won aerial and physical duels, and the number of fouls earned in the final third (fouledFinalThird). Such composite metrics allow identifying players who may not score much yet but systematically get into sharp positions and create threats — this is an important signal for scouting and betting on long-term markets.
Using Sport Events API, you can aggregate advanced metrics by seasons, tournaments, and specific segments (for example, the last 10 rounds), build cohorts of attackers with similar profiles, and compare their impact on the game with market expectations through oddsBase data. Support for different sports (football, hockey, basketball, tennis, esports, and others) allows replicating the approach to advanced metrics in other disciplines where the performance of attacking players or lines is important. All of this forms a powerful foundation for club analytics, betting, fantasy platforms, and media projects.
# Пример: агрегируем часть продвинутых метрик команды по списку матчей
import requests
API_KEY = 'ВАШ_API_КЛЮЧ'
SPORT = 'football'
match_ids = [14570728, 14586240]
headers = {'Authorization': API_KEY}
touches_total = 0
final_third_entries = 0
matches_count = 0
for mid in match_ids:
r = requests.get(f'https://api.api-sport.ru/v2/{SPORT}/matches/{mid}', headers=headers)
match = r.json()
stats_all = next(s for s in match['matchStatistics'] if s['period'] == 'ALL')
attack_group = next(g for g in stats_all['groups'] if g['groupName'] == 'Attack')
passes_group = next(g for g in stats_all['groups'] if g['groupName'] == 'Passes')
touches_item = next(i for i in attack_group['statisticsItems'] if i['key'] == 'touchesInOppBox')
final_third_item = next(i for i in passes_group['statisticsItems'] if i['key'] == 'finalThirdEntries')
# Для примера считаем метрики хозяев
touches_total += touches_item['homeValue']
final_third_entries += final_third_item['homeValue']
matches_count += 1
print('Средние касания в штрафной за матч:', touches_total / matches_count)
print('Средние входы в последнюю треть за матч:', final_third_entries / matches_count)
How to automate the calculation of forward metrics based on API data
For attacking metrics to provide real benefits, they need to be calculated regularly and without manual labor. A typical pipeline based on the Sport Events API looks like this: on a schedule, the service polls the /v2/football/matches endpoints with filters by tournament, season, or team, retrieves a fresh list of matches, then requests details for each match (/v2/football/matches/{matchId}) and events (/v2/football/matches/{matchId}/events). The data is then saved to an internal database, where derived metrics are calculated — goals and shots per 90 minutes, xG/xA according to your models, attack and pressing participation indices, forward ratings by club or league.
Such architecture is easily scalable: you can parallelize requests by competitions, store different slices (by seasons, tournaments, player roles), and update data warehouses for different teams of analysts, coaches, and traders. In the near future, the introduction of a WebSocket stream in the API will simplify working with live data: instead of frequent polling, the server will push updates on match events, and you will be able to build online models of attacking effectiveness, track the dynamics of their xG and engagement right during the game. Additional AI tools will allow automating the search for anomalies and new patterns in forwards’ play.
To get started, it is enough to obtain an API key at your personal account at api-sport.ru, set up authorization via the Authorization header, and integrate calls into your service or analytics scripts. Below is a minimal example in Python that pulls matches for a team once per run, calculates simple metrics for shots, and can be expanded into a full ETL pipeline with the calculation of complex attacking metrics, storage, and dashboard creation in BI systems.
# Пример: упрощённый скрипт для обновления метрик по матчам команды
import requests
API_KEY = 'ВАШ_API_КЛЮЧ'
TEAM_ID = 195801
SPORT = 'football'
headers = {'Authorization': API_KEY}
# 1. Получаем матчи команды на сегодня
params = {'team_id': TEAM_ID}
resp = requests.get(f'https://api.api-sport.ru/v2/{SPORT}/matches', headers=headers, params=params)
matches = resp.json()['matches']
for m in matches:
match_id = m['id']
detail = requests.get(f'https://api.api-sport.ru/v2/{SPORT}/matches/{match_id}', headers=headers).json()
# пример: достаём общее число ударов команды хозяев
stats_all = next(s for s in detail['matchStatistics'] if s['period'] == 'ALL')
shots_group = next(g for g in stats_all['groups'] if g['groupName'] == 'Shots')
total_shots = next(i for i in shots_group['statisticsItems'] if i['key'] == 'totalShotsOnGoal')
print(f"Матч {match_id}: удары команды хозяев = {total_shots['homeValue']}")
# здесь можно продолжить: привязать к игрокам, пересчитать метрики за 90 минут и сохранить в БД
