Where to find reliable statistics on outs, offsides, fouls, and cards?

Where to view statistics on throw-ins, offsides, fouls, and cards online

If you need honest and timely statistics on throw-ins, offsides, fouls, and cards online, relying solely on television footage or text live broadcasts is no longer sufficient. Such formats are convenient for fans but are not suitable for analytics, betting automation, model building, and working with large data sets. For developers, analysts, and betting projects, it is critical to have formalized access to match events: the number of throw-ins (throwIns), offsides (offsides), fouls (fouls), and cards (via liveEvents and aggregate metrics like yellowCards) tied to time and team.

A reliable solution is to connect to a sports statistics API that obtains data from professional sources, processes it, and provides it in a unified structured format. In the case of football, the service api-sport.ru provides endpoints for retrieving a list of matches and their detailed statistics. It is enough to request information about a match via the method /v2/football/matches or /v2/football/matches/{matchId}, to receive an array in the response matchStatistics and a list of live events liveEvents. In the statistics fields, you will see how many outs, fouls, and offsides each team made for the match as a whole and for individual halves, and in the events – all cards with the exact minute and player.

This format is especially convenient when you need to display live statistics on a website, in a mobile application, or use it in forecasting models. You receive a single JSON response with key fields: match status, current minute (currentMatchMinute), score, summary statistics (matchStatistics), as well as live events (liveEvents), where event types card allow tracking yellow and other cards in real time. All of this can be updated at a specified frequency without overloading the interface and server. Below is an example of a basic request to obtain online statistics for football matches today:

curl -X GET "https://api.api-sport.ru/v2/football/matches?date=2025-09-03&status=inprogress" \
  -H "Authorization: YOUR_API_KEY"

In the response, you will receive a list of matches with the field matchStatistics, where you can extract values by keys fouls, offsides, throwIns, yellowCards and other metrics for each team. This is the basis for any online services that want to show the audience detailed statistics not only on goals but also on the game nuances that affect the outcome of the match.

The best services and websites for statistics on throw-ins, offsides, fouls, and cards for Russia

In the Russian market, there are several groups of sources for football statistics: official league and federation websites, international statistical portals, bookmaker resources, and independent aggregators. They can display the number of fouls, offsides, throw-ins, and cards per match, however, such data is almost always oriented towards visual viewing by a person. The format of information presentation varies from site to site, there is no single standard for structure, field names, and filtering methods. For projects where it is important to scale the processing of statistics and integrate it into their services, such an approach leads to unnecessary labor costs and errors.

The key problem of most «classic» statistics websites is that they rarely provide full programmatic access through a well-documented API. Even if such entry points exist, they are often limited to a specific sport, league, or region, and the format of responses can change without a clearly described version. As a result, developers have to either parse HTML pages or maintain many different integrations. It is much more efficient to use a single service that collects data from reliable sources and provides it through a standardized API for different sports and tournaments.

This is the model implemented by the platform api-sport.ru. Instead of manually merging statistics for Russia and international leagues, you get access to a single entry point for football, hockey, basketball, tennis, table tennis, and esports. For each football match, a structure is available matchStatistics, which includes fouls, throw-ins, offsides, and cards, as well as the method /v2/{sportSlug}/matches/{matchId}/events with all game events. This means you can build a service with the detail level of the best international statistical portals, but with simple integration and a focus on the Russian market.

Below is an example of a request for football match events that allows you to get all cards and other key episodes:

curl -X GET "https://api.api-sport.ru/v2/football/matches/14570728/events" \
  -H "Authorization: YOUR_API_KEY"

In the response, you will see an array события with objects of type card, where the time is specified (время), team (команда) and player (игрок). Combining this endpoint with the field matchStatistics, you get both aggregated metrics for fouls, throw-ins, and offsides, as well as detailed events for each card — at a level that is difficult to obtain relying solely on classic statistics websites.

Football statistics API: what data on throw-ins, offsides, fouls, and cards can be obtained

Football API based on the service api-sport.ru provides detailed match statistics through the object матч. The key element for analyzing throw-ins, offsides, fouls, and cards is the array matchStatistics. This is a structured set of statistics for different periods of the match: the entire match (period: "ALL"), first half ("1ST") and second half ("2ND"). Inside each period, the data is grouped into blocks (группы): «Match overview», «Passes», «Attack» and others. In each block, there is an array statisticsItems, where each element describes a specific metric, its name, value for the home and away teams, type, and technical key.

The metrics of interest to us are presented in different groups. For example, fouls are recorded with a metric that has the key fouls, and offsides — a metric with a key offsides in the «Attack» group. Throws (throw-ins from the side) appear as an indicator throwIns in the «Passes» group. Cards are presented in the summary statistics at least through the indicator yellowCards, and more detailed information about cards is available in the array liveEvents, where event types card include time, team, and player. This approach allows for aggregated numbers for the match while also being able to drill down to specific episodes when needed.

Below is an example of JavaScript code that shows how to get a match and extract values for throw-ins, offsides, fouls, and yellow cards:

fetch('https://api.api-sport.ru/v2/football/matches/14570728', {
  headers: {
    Authorization: 'YOUR_API_KEY'
  }
})
  .then(res => res.json())
  .then(match => {
    const statsAll = match.matchStatistics.find(s => s.period === 'ALL');
    const allItems = statsAll.groups.flatMap(g => g.statisticsItems);
    const getValue = key => {
      const item = allItems.find(i => i.key === key);
      return item ? { home: item.homeValue, away: item.awayValue } : null;
    };
    const fouls = getValue('fouls');
    const offsides = getValue('offsides');
    const throwIns = getValue('throwIns');
    const yellowCards = getValue('yellowCards');
    console.log({ fouls, offsides, throwIns, yellowCards });
  });

Using such a structure, you can build any reports: compare team discipline by seasons, analyze the load on the flanks through the number of throw-ins, see how often a team is caught offside depending on the opponent or the minute of the match. Additionally, in the object матч there is a block oddsBase with betting odds, which allows linking the statistics of fouls, throw-ins, offsides, and cards with the bookmakers’ line and using the data not only for analytics but also for building your own betting tools.

How to connect to the sports events API and get statistics on throw-ins, offsides, fouls, and cards

Connecting to the sports events API starts with registration and obtaining an API key. On the api-sport platform, it is enough to create an account and in the personal account obtain the API key, which will be used for authorizing each request. The key is passed in the header Authorization. Next, you choose the sport: a list of available slugs (for example, football, ice-hockey, basketball) can be obtained through the method /v2/sport. For our task, we are interested in football, so the paths use /v2/football/....

After obtaining the key and selecting the sport, you determine which matches need to be analyzed: matches for the day, matches of a specific team, a tournament, or a specific match by ID. This is done using the method /v2/{sportSlug}/matches with filtering parameters: дата, team_id, tournament_id, status and others. To get advanced statistics, including outs, fouls, offsides, and cards, it is enough to request a list of matches with the necessary parameters or a specific match through /v2/football/matches/{matchId}. In the response, you will receive an object матч with a block matchStatistics and a list liveEvents.

Below is an example of a step-by-step request: first, we get matches of a specific tournament on a date, then we select the desired match and load its statistics:

# 1. Получаем список футбольных матчей турнира на дату
curl -X GET "https://api.api-sport.ru/v2/football/matches?date=2025-09-03&tournament_id=25182" \
  -H "Authorization: YOUR_API_KEY"
# 2. Берём нужный matchId из ответа и запрашиваем полную статистику
curl -X GET "https://api.api-sport.ru/v2/football/matches/14570728" \
  -H "Authorization: YOUR_API_KEY"

Next, you process the field matchStatistics on your side. For example, you can extract the keys of interest (fouls, offsides, throwIns, yellowCards) into separate database tables to then build reports and visualizations. If necessary, you can periodically update the match data in the status inprogress, thereby creating your own live center based on a reliable and standardized source.

Free and paid football statistics APIs: comparison of capabilities and limitations

When choosing a data source for fouls, offsides, throw-ins, and cards, it is important to understand the differences between free and commercial APIs. Free solutions are often limited in functionality: they either provide only basic data (score, goal scorers), impose strict limits on the number of requests, or prohibit commercial use of the collected information. As a result, it can be difficult to build a reliable betting service, an analytical platform, or a product for a mass audience on such an API: there is a lack of statistical depth and guarantees of availability.

Paid APIs, including the api-sport platform, focus on stability, data completeness, and predictability. Under one contract, you receive detailed statistics on throw-ins, offsides, fouls, and cards, match history over several seasons (if provided by the tariff), detailed live events, and, in the case of oddsBase, current bookmaker odds across different markets and match periods. Commercial solutions typically have clear API versioning, understandable documentation (as in the case of endpoints /v2/{sportSlug}/matches, /v2/{sportSlug}/matches/{matchId}, /v2/{sportSlug}/matches/{matchId}/events) and technical support.

A separate plus of such services is product development. On the api-sport platform, in addition to the already implemented REST endpoints for different sports and betting odds, the addition of WebSocket connections for even more timely updates and AI tools for advanced analytics is planned. This allows building solutions not only for classic statistics display but also for complex recommendation systems and models. A typical scenario for working with a paid API looks like this: you register, configure the tariff according to your volumes, and use the authorization key in all requests. Then, you only need to integrate the API responses into your infrastructure. An example of a simple request for matches with odds and statistics is shown below:

curl -X GET "https://api.api-sport.ru/v2/football/matches?date=2025-09-03&status=finished" \
  -H "Authorization: YOUR_API_KEY"

In the response, you receive not only the score and status but also blocks matchStatistics (fouls, throw-ins, offsides, cards) and oddsBase (betting markets and odds). This combination of capabilities is rarely found in free APIs and allows commercial projects to build competitive services with a high level of data detail.

How to use the statistics API for throw-ins, offsides, fouls, and cards in your applications and services

After connecting to the sports events API, the next step is the proper use of statistics on throw-ins, offsides, fouls, and cards in products. In practice, such data is applied in several key scenarios. First, it is betting analytics: by the dynamics of fouls and cards, one can assess the tension of the match, the referee’s behavior, and the risks of disciplinary sanctions for the team. Throw-ins and offsides help analyze the style of play, the degree of pressure, and risky high defensive lines. Second, it is media and content: interactive graphs of fouls and cards by minutes, heat maps of activity, and comparisons of teams by throw-ins increase audience engagement on sports portals and applications.

Third, data on throw-ins, offsides, and fouls are actively used in machine learning models. Based on them, one can predict the likelihood of the next events, assess teams’ resilience to pressing, and calculate the risk of ejection. An important advantage of APIs like the one available through api-sport.ru is that the structure matchStatistics и liveEvents is the same for all tournaments and matches. This simplifies the preparation of datasets: it is enough to write a key extraction module fouls, offsides, throwIns, yellowCards and event types once. card, after which scale the solution to thousands of matches.

Below is an example of JavaScript code that shows how to based on the response матч compile a summary of the key metrics of interest to us and prepare the data for visualization or further analytics:

async function loadDisciplineStats(matchId) {
  const res = await fetch(`https://api.api-sport.ru/v2/football/matches/${matchId}`, {
    headers: { Authorization: 'YOUR_API_KEY' }
  });
  const match = await res.json();
  const allPeriod = match.matchStatistics.find(s => s.period === 'ALL');
  const items = allPeriod.groups.flatMap(g => g.statisticsItems);
  const pick = key => items.find(i => i.key === key);
  const summary = {
    fouls: pick('fouls'),
    offsides: pick('offsides'),
    throwIns: pick('throwIns'),
    yellowCards: pick('yellowCards')
  };
  // здесь можно передать summary в графики, таблицы или ML-модель
  return summary;
}

By using such functions, you can easily integrate disciplinary and game statistics into your dashboards, recommendation blocks, or notification modules. In combination with the coefficients from oddsBase you can build systems to highlight «anomalous» matches, where the number of fouls or cards significantly differs from the average level. As the platform evolves (connecting WebSocket and AI modules), such scenarios will become even more powerful: data on outs, offsides, fouls, and cards can be obtained almost instantly and used in real-time for complex algorithms and personalized recommendations.