Soccer Advanced Analytics v1

Frequently Asked Questions
Quick Access
Postman Collection XSD Schema
Download
## Soccer Advanced Analytics API Overview Our Soccer Advanced Analytics API provides real-time match updates with cutting edge advanced statistics. Our highly skilled team collects deeper events and derived statistics, using universal standards for soccer definitions. 2,000+ unique events are created (with attributes and outcomes) per game. 100+ player and team stat types are tracked per game. Advanced statistics are available for select top leagues. See our Coverage Matrix for a detailed breakdown of competitions and data offered. Subscription to this package will also include access to lower tiered competitions via Soccer v4. The Soccer Advanced Analytics API is consistent in structure, format and behavior with the Soccer v4 API. Primary feeds will return seasons, competitions, team/player data and real-time scores. Additional feeds provide a host of complementary stats, including:
  • Live standings for top leagues
  • League leaders
  • Win probabilities for every match
  • Lineups with formations
  • Seasonal statistics
  • Missing/Injured players
  • Live ball-spotting data (x,y coordinates for events on the field)
  • Head-to-head statistics
  • Fun facts
API API Version
Soccer Advanced Analytics v1
Note: Authentication is required for all API calls.
## API Map To best utilize the Soccer Advanced Analytics API, you will need several parameters to create your API calls. The map below illustrates how you can obtain the parameters you need. >

Examples:

>To find the fun facts for a given match: >
  1. Call the daily schedule for the date of the match and find the Sport Event Id for the chosen match
  2. Call the Sport Event Fun Facts using the Sport Event Id
  3. Locate the Fact Statement
>The fun facts for the match are displayed. >
    >To find a teams number of completed forward passes: >
    1. Call the daily schedule for the date of the match and find the Sport Event Id for the chosen match
    2. Call the Sport Event Summary using the Sport Event Id
    3. Locate the completed forward passes attribute (passes_forward_complete)
    >The teams number of completed forward passes is displayed. Primary and mapping feeds only require dates, human-readable parameters or a Competition Id (which can be found in the competitions endpoint), while other feeds require a global unique identifier (GUID) to identify the sport event, competitor, or player that the feed will describe. The primary feeds provide GUIDs for sport events, competitions, and competitors, while sport event and competitors provide GUIDS for players. ## Advanced Analytics Data Dictionary See below for a breakdown of all advanced statistics provided, including definitions. ### Events
    Event Definition
    pass A ball action that has the intention to send the ball to a Player of the same team. Ball actions that belong to Set play are not counted as passes.
    duel An Action where two Players of the opposite Teams at the same moment try to influence the ball with the intention to play the ball.
    cross A ball action, pass or free kick that is a cross.
    foul_against Player commits a foul
    interception Action with which possession was regained that is not a duel.
    clearance A Ball-action where the player plays the ball without having the intention to reach a team mate. The purpose of the action is to keep the ball away from the own goal.
    goalkeeper_throw Pass is a throw by hands of keeper.
    goalkeeper_control Action performed by a goalkeeper to control the ball.
    block A Ball-action where the player blocks a play action or Goal attempt of a player of the opponent team.
    ball_distribution Advancing the ball with the feet in the direction of the opponent’s goal over a minimum of 5 meters.
    touch An action where a player touched the ball unintended. For example, when a teammate shoots against the player or an opponent passes the ball against the player so the ball changes of direction.
    out_of_play Ball goes out of play
    ### Statistics
    Event Definition
    aerial_duels_defensive A defensive duel, that is a duel an has attribute air
    aerial_duels_defensive_won A defensive duel with air attribute that is won (see won definition)
    aerial_duels_offensive An offensive duel, that is a duel an has attribute air
    aerial_duels_offensive_won An offensive duel with air attribute that is won (see won definition)
    assists A key action on a goal attempt that is scored
    assists_by_free_kick A free kicks that counts as an assist
    attempts_at_goal_blocked A defensive blocking action on a shot of the opponent
    attempts_at_goal_inside_
    the_penalty_area
    A shot inside the box
    attempts_at_goal_inside_
    the_penalty_area_on_target
    A shot inside the box that is saved or is a goal
    attempts_at_goal_inside_
    the_penalty_area_scored
    A shot inside the box and is a goal
    attempts_at_goal_outside_
    the_penalty_area
    A shot outside the box
    attempts_at_goal_outside_
    the_penalty_area_on_target
    A shot outside the box that is saved or is a goal
    attempts_at_goal_outside_
    the_penalty_area_scored
    A shot outside the box and is a goal
    ball_progression A move with the ball by the player without encountering a opponent, only moves longer than 5m are tagged
    ball_progression_complete A completed move with the ball by the player without encountering a opponent, only moves longer than 5m are tagged
    ball_progression_incomplete A failed move with the ball by the player without encountering a opponent, only moves longer than 5m are tagged
    clearances A defensive action with a attribute clearance
    corners The number of corner kicks taken by a player/team.
    corners_long A corner that is not short
    corners_short A corner taken short
    crosses Pass with attribute cross
    crosses_completed A pass with attribute cross that is complete
    crosses_early A cross given before the horizontal line of the box
    crosses_high A cross given through the air
    crosses_incomplete A pass with attribute cross that is incomplete
    crosses_late A cross given after the horizontal line of the box
    crosses_low A cross given over the ground
    crosses_to_attempt_at_goal A cross that lead to a goal attempt of team mate
    crosses_to_goal A free kick that is directly shot on goal resulting in a goal
    direct_red_cards A direct red card
    diving_saves A more advanced save that requires skill from the goalkeeper to dive.
    duels_complete Duels defensive or offensive that are complete
    duels_defensive Total number of defensive duels
    duels_defensive_opponents_half Number of defensive duels on opponent half
    duels_defensive_opponents_half_won Number of defensive duels on opponent half won
    duels_defensive_own_box Number of defensive duels on own box
    duels_defensive_own_box_won Number of defensive duels on own box won
    duels_defensive_own_half Number of defensive duels on own half
    duels_defensive_own_half_won Number of defensive duels on own half won
    duels_defensive_won Total number of defensive duels won
    duels_fifty_fifty Number of duels, that have a duel as previous action
    duels_incomplete Duels defensive or offensive that are incomplete
    duels_offensive Total number of off duels
    duels_offensive_won Total number of off duels won
    duels_sliding A defensive action with attributes sliding
    duels_total Duels defensive or offensive
    events The number of ball actions a player made during the match
    events_inside_box The number of ball actions a player made during the match that occurred inside the box
    events_key An action that leads to a goal attempt of a teammate. It is the action before a goal attempt from another player of the same team without a clearance or pass of the opponent between it
    events_key_corner A corner kick that is a key action
    events_key_freekick A free kick that is a key action
    events_successful The number of actions that are successful, for each type of action we have a definition of what is successful
    fouls_against A foul is given against the team/player
    fouls_for A foul is given for the team/player
    fouls_own_half A foul conceded in their own half
    free_kicks Total number of free kicks taken
    free_kicks_missed Total number of free kicks off target
    free_kicks_on_goal Total number of free kicks that are saved or a goal
    free_kicks_scored Total number of free kicks that are a goal
    goal_kicks Total number of goal kicks taken
    goals Total amount of goals scored
    grade Every action is rated by analysts with an overall match grade created from this
    ground_duels_defensive A defensive duel with no air attribute
    ground_duels_defensive_won A defensive ground duel that is won (see won definition)
    ground_duels_offensive An offensive duel with no air attribute
    ground_duels_offensive_won An offensive ground duel that is won (see won definition)
    interceptions_goalkeeper A interception of the goalkeeper by his hands on a long ball or cross, either intercepted by caught or punch
    involvement_in_attempt_at_goal Number of times an action in a possession ends with goal attempt
    involvement_in_attempt_at_goal_xg Total xG of goal attempts in which player has an action
    keeper_throws_long A pass with attribute throw and length >30
    keeper_throws_short A pass with attribute throw and length <20
    offsides Total of offsides called
    own_goals Total of own goals scored
    passes Any pass that is attempted
    passes_backward Passes with angle between 102.5 and 257.5
    passes_backward_complete Both Backwards and completed
    passes_between_central_defenders A pass between two central defenders
    passes_complete Tagged passes that have a next action of the same team
    passes_direct A pass with attribute directly played
    passes_first_in_possession The first pass in a possession moment
    passes_first_in_possession_forward A first pass that is also forward
    passes_forward Passes with angle between 0 and 77.5 or 282.5 and 360 degrees
    passes_forward_complete Both forward and completed
    passes_in_final_third A pass is given in the last 30m of the field
    passes_in_final_third_complete A pass is given in the last 30m of the field completed
    passes_incomplete A pass that is attempted but incomplete
    passes_into_box A pass given from outside the opponents box that ends in the opponent box
    passes_key A pass that lead to a goal attempt
    passes_long Passes with length >30
    passes_long_complete Passes with length >30 completed
    passes_long_incomplete Passes with length >30 incompleted
    passes_opponents_half A pass on the opponent half
    passes_opponents_half_complete A pass on the opponent half completed
    passes_own_half A pass in their own half
    passes_short Passes with length <30
    passes_switch A pass that crosses the vertical midline and the difference in wide of the field between starting point and ending point is 30m
    passes_wide Passes with angle between 77.5 and 102.5 or 257.5 and 282.5 degrees
    passes_wide_complete Both wide and completed
    penalties_faced Total number of penalties faced (excluding shootouts)
    penalties_saved Total number of penalties saved (excluding shootouts)
    possession_opponents_half Percentage passes opponent half / total passes
    possessions_lost The last action of a ball possession moment
    possessions_lost_by_duel A possession lost action that is a duel
    possessions_lost_by_passes A possession lost action that is a pass
    possessions_regained_
    by_duel
    First action of possession moment that is a duel
    possessions_regained_
    by_interception
    First action of possession moment that is neither a duel or a dead moment
    possessions_regained_
    in_opponents_half
    A possession regain by duel of interception on the opponent half
    possessions_time Total Time a team has the ball in possession in minutes
    red_cards_for_second_caution A red card as a result of two yellow card cautions
    throw_ins Total amount of throw ins taken
    throw_ins_keep_possession Throw ins with 3 actions of same team
    total_x_location The totalX and totalY location can be used to calculate the average location per match
    total_y_location The totalX and totalY location can be used to calculate the average location per match
    xg_value Expected goal value of all goal attempts
    yellow_cards Total amount of yellow cards received
    ## Failover Information

    If we lose connection with our scout feed, Sportradar Production performs failover.

    Up to live coverage tier 2 failover is in place in the situation where there are any issues with primary live coverage for deeper player or team stats such as shots, corners, assists and offsides.

    For our Advanced Analytics coverage, there is no live failover in place in case of any issues with primary coverage. Data will be updated post-match.

    ## Competition Info Provides the name, id, and parent id for a given competition.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Category & Sport Info: Category Country Code Category Id Category Name
    Competition Info Data Points: Gender
    Id
    Name Parent Id
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitions/sr:competition:242/info.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/competitions/sr:competition:242/info.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitions/sr:competition:242/info.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Competition Info feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/competitions/`{competition_id}`/info.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `competition_id` | Id of a given competition | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Competition Seasons Provides historical season information for a given competition. Valid competition IDs can be found in the Competitions feed.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competition Info Data Points: Season Competition Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Year
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitions/sr:competition:242/seasons.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/competitions/sr:competition:242/seasons.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitions/sr:competition:242/seasons.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Competition Seasons feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/competitions/`{competition_id}`/seasons.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `competition_id` | Id of a given competition | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Competitions Provides a list of all available Soccer competitions.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Category & Sport Info: Category Country Code Category Id Category Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name Competition Parent Id
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitions.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/competitions.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitions.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Competitions feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/competitions.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Competitor Mappings Provides competitor Id mapping between previous versions of the Soccer API.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Mappings Info Data Points: External Id
    Id
    Merged Id Retained Id
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitors/mappings.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/competitors/mappings.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitors/mappings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Competitor Mappings feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/competitors/mappings.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Competitor Merge Mappings Provides the valid Sportradar Id in cases when two competitors have been merged into one. Entries are retained in this endpoint for one week.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Mappings Info Data Points: Name
    Id
    Merged Id Retained Id
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitors/merge_mappings.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/competitors/merge_mappings.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitors/merge_mappings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Competitor Merge Mappings feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/competitors/merge_mappings.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Competitor Profile Provides top-level information for a given team, including the full team roster, manager, home venue, and team colors.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Jersey Base Color
    Jersey Horizontal Stripes
    Jersey Horizontal Stripes Color
    Jersey Number Color
    Jersey Shirt Type
    Jersey Sleeve Color
    Jersey Sleeve Detail
    Jersey Split
    Jersey Split Color
    Jersey Squares
    Jersey Squares Color
    Jersey Stripes
    Jersey Stripes Color
    Jersey Type
    Manager Country Code
    Manager Date of Birth
    Manager Gender
    Manager Id
    Manager Name
    Manager Nationality
    Manager Nickname
    Manager Place of Birth
    Manager Preferred Foot
    Player Info Data Points: Country Code
    Date of Birth
    Gender
    Height
    Id
    Jersey Number
    Name
    Nationality
    Nickname
    Place of Birth
    Preferred Foot
    Type
    Weight
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitors/sr:competitor:41618/profile.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/competitors/sr:competitor:41618/profile.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitors/sr:competitor:41618/profile.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Competitor Profile feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/competitors/`{competitor_id}`/profile.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `competitor_id` | Id of a given competitor | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Competitor Schedules Provides previous and upcoming match information for a given competitor.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Sport Event Info Data Points: Attendance Count
    Channel Country
    Channel Name
    Channel URL
    Coverage Type
    Ground Neutral
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Lineups Confirmed
    Referee Id
    Referee Name
    Referee Nationality
    Referee Country Code
    Referee Type
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Weather Overall Conditions
    Weather Pitch Conditions
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation - Qualifier
    Match Situation - Status
    Match Situation - Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Play by Play Info Data Points: Qualifier
    Order
    X Coordinate Y Coordinate
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitors/sr:competitor:41618/schedules.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/competitors/sr:competitor:41618/schedules.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitors/sr:competitor:41618/schedules.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Competitor Schedules feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/competitors/`{competitor_id}`/schedules.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `competitor_id` | Id of a given competitor | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Competitor vs Competitor Schedules Provides previous and upcoming matches between two teams.
    TTL / Cache: 60 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Sport Event Info Data Points: Attendance Count
    Channel Country
    Channel Name
    Channel URL
    Coverage Type
    Ground Neutral
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Lineups Confirmed
    Referee Id
    Referee Name
    Referee Nationality
    Referee Country Code
    Referee Type
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Weather Overall Conditions
    Weather Pitch Conditions
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation - Qualifier
    Match Situation - Status
    Match Situation - Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Play by Play Info Data Points: Qualifier
    Order
    X Coordinate Y Coordinate
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitors/sr:competitor:41618/versus/sr:competitor:22010/schedules.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/competitors/sr:competitor:41618/versus/sr:competitor:22010/schedules.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/competitors/sr:competitor:41618/versus/sr:competitor:22010/schedules.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Competitor vs Competitor Schedules feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/competitors/`{competitor_id}`/versus/`{competitor_id2}`/schedules.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `competitor_id` | Id of a given competitor | | `competitor_id2` | Id of a given competitor | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Daily Schedules Provides a list of all scheduled matches on a given day.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Sport Event Info Data Points: Attendance Count
    Channel Country
    Channel Name
    Channel URL
    Coverage Type
    Ground Neutral
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Lineups Confirmed
    Referee Id
    Referee Name
    Referee Nationality
    Referee Country Code
    Referee Type
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Weather Overall Conditions
    Weather Pitch Conditions
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation - Qualifier
    Match Situation - Status
    Match Situation - Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Play by Play Info Data Points: Qualifier
    Order
    X Coordinate Y Coordinate
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/schedules/2023-02-25/schedules.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/schedules/2023-02-25/schedules.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/schedules/2023-02-25/schedules.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Daily Schedules feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/schedules/`{year}`-`{month}`-`{day}`/schedules.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `year` | Year in 4 digit format (YYYY) | | `month` | Month in 2 digit format (MM) | | `day` | Day in 2 digit format (DD) | | `format` | xml or json | | `your_api_key` | Your API key | ### Optional Query String Parameters >Example including optional query string parameters:
    require 'uri'
    require 'net/http'
    require 'openssl'
    
    url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/schedules/2023-02-25/schedules.xml?api_key={your_api_key}&start=0&limit=75")
    
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    
    request = Net::HTTP::Get.new(url)
    
    response = http.request(request)
    puts response.read_body
    
    import http.client
    
    conn = http.client.HTTPSConnection("api.sportradar.com")
    
    conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/schedules/2023-02-25/schedules.xml?api_key={your_api_key}&start=0&limit=75")
    
    res = conn.getresponse()
    data = res.read()
    
    print(data.decode("utf-8"))
    
    curl -L GET 'api.sportradar.com/soccer-advanced-analytics/trial/v1/en/schedules/2023-02-25/schedules.xml?api_key={your_api_key}&start=0&limit=75'
    
    In addition to the URL parameters listed above, you can paginate the event information with one or more of the following optional query string parameters.
    Note: Optional query string parameters must be added after your API key with an ampersand (&).
    Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `start` | Number to start the list of results from.
    Example: start=0 | | `limit` | Number to limit the number of results. Minimum value is 1, maximum value is 200.
    Example: limit=200 | Return to top ## League Timeline Provides league-based post-match scoring, match statistics, and a play-by-play event timeline.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Player Info Data Points: Id
    Name
    Starter Type
    Sport Event Info Data Points: Attendance Count
    Channel Country
    Channel Name
    Channel URL
    Coverage Type
    Ground Neutral
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Lineups Confirmed
    Referee Id
    Referee Name
    Referee Nationality
    Referee Country Code
    Referee Type
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Weather Overall Conditions
    Weather Pitch Conditions
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation - Qualifier
    Match Situation - Status
    Match Situation - Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Play by Play Info Data Points: Away Team Score
    Ball Location Qualifier
    Ball Location Order
    Ball Location X Coordinate
    Ball Location Y Coordinate
    Event Break Name
    Event Card Description
    Event Commentary
    Event Competitor
    Event Coordinate X
    Event Coordinate Y
    Event Id
    Event Injury Time Announced
    Event Match Clock
    Event Match Time
    Event Method
    Event Outcome
    Event Period
    Event Period Name
    Event Period Type
    Event Shootout Away Score
    Event Shootout Home Score
    Event Status
    Event Stoppage Time
    Event Type
    Event Time
    Home Team Score
    Play Details Data Points: Assisting Player Id
    Assisting Player Method
    Assisting Player Name
    Assisting Player Type
    Goal Scorer Id
    Goal Scorer Method
    Goal Scorer Name
    Goal Scorer Type
    Substitution Player In Id
    Substitution Player In Method
    Substitution Player In Name
    Substitution Player In Type
    Substitution Player Out Id
    Substitution Player Out Method
    Substitution Player Out Name
    Substitution Player Out Type
    Player Match Statistics Data Points: Assists
    Goals
    Own Goals
    Red Cards
    Substituted In
    Substituted Out
    Yellow Cards
    Yellow/Red Cards
    Team Match Statistics Data Points: Assists
    Ball Possession
    Corner Kicks
    Fouls
    Goals
    Offside
    Red Cards
    Shots
    Shots on Goal
    Substitutions
    Yellow Cards
    Yellow/Red Cards
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/league_timeline.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/league_timeline.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/league_timeline.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the League Timeline feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{sport_event_id}`/league_timeline.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `sport_event_id` | Id of a given sport event | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Live Schedules Provides match information for all currently live matches.
    TTL / Cache: 300 seconds
    Update Frequency: Realtime
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Sport Event Info Data Points: Attendance Count
    Channel Country
    Channel Name
    Channel URL
    Coverage Type
    Ground Neutral
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Lineups Confirmed
    Referee Id
    Referee Name
    Referee Nationality
    Referee Country Code
    Referee Type
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Weather Overall Conditions
    Weather Pitch Conditions
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation - Qualifier
    Match Situation - Status
    Match Situation - Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Play by Play Info Data Points: Qualifier
    Order
    X Coordinate Y Coordinate
    Play by Play Info Data Points: Qualifier
    Order
    X Coordinate Y Coordinate
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/schedules/live/schedules.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/schedules/live/schedules.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/schedules/live/schedules.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Live Schedules feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/schedules/live/schedules.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `format` | xml or json | | `your_api_key` | Your API key | ### Optional Query String Parameters >Example including optional query string parameters:
    require 'uri'
    require 'net/http'
    require 'openssl'
    
    url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/schedules/live/schedules.xml?api_key={your_api_key}&start=0&limit=75")
    
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    
    request = Net::HTTP::Get.new(url)
    
    response = http.request(request)
    puts response.read_body
    
    import http.client
    
    conn = http.client.HTTPSConnection("api.sportradar.com")
    
    conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/schedules/live/schedules.xml?api_key={your_api_key}&start=0&limit=75")
    
    res = conn.getresponse()
    data = res.read()
    
    print(data.decode("utf-8"))
    
    curl -L GET 'api.sportradar.com/soccer-advanced-analytics/trial/v1/en/schedules/live/schedules.xml?api_key={your_api_key}&start=0&limit=75'
    
    In addition to the URL parameters listed above, you can paginate the event information with one or more of the following optional query string parameters.
    Note: Optional query string parameters must be added after your API key with an ampersand (&).
    Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `start` | Number to start the list of results from.
    Example: start=0 | | `limit` | Number to limit the number of results. Minimum value is 1, maximum value is 200.
    Example: limit=200 | Return to top ## Player Mappings Provides player id mapping between previous versions of the Soccer API.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Mappings Info Data Points: External Id
    Id
    Merged Id Retained Id
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/players/mappings.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/players/mappings.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/players/mappings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Player Mappings feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/players/mappings.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Player Merge Mappings Provides valid ids for players who have had their profiles merged. While Sportradar always strives to provide one unique player id, it is a possibility for two ids to be created. This feed provides the correct id once profiles have been merged. Entries are retained in this endpoint for one week.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Mappings Info Data Points: Name
    Id
    Merged Id Retained Id
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/players/merge_mappings.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/players/merge_mappings.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/players/merge_mappings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Player Merge Mappings feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/players/merge_mappings.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Player Profile Provides player information, including current and historical team membership info.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Player Info Data Points: Country Code
    Date of Birth
    Gender
    Height
    Id
    Jersey Number
    Name
    Nationality
    Nickname
    Place of Birth
    Preferred Foot
    Team Membership Active Flag
    Team Membership End Date
    Team Membership Jersey Number
    Team Membership Start Date
    Team Membership Type
    Type
    Weight
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/players/sr:player:1059961/profile.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/players/sr:player:1059961/profile.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/players/sr:player:1059961/profile.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Player Profile feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/players/`{player_id}`/profile.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `player_id` | Id of a given player. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Player Schedules Provides match info for the past 10 matches in which a given player participated.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Sport Event Info Data Points: Attendance Count
    Channel Country
    Channel Name
    Channel URL
    Coverage Type
    Ground Neutral
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Lineups Confirmed
    Referee Id
    Referee Name
    Referee Nationality
    Referee Country Code
    Referee Type
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Weather Overall Conditions
    Weather Pitch Conditions
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation - Qualifier
    Match Situation - Status
    Match Situation - Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Play by Play Info Data Points: Qualifier
    Order
    X Coordinate Y Coordinate
    Play by Play Info Data Points: Qualifier
    Order
    X Coordinate Y Coordinate
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/players/sr:player:1059961/schedules.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/players/sr:player:1059961/schedules.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/players/sr:player:1059961/schedules.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Player Schedules feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/players/`{player_id}`/schedules.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `player_id` | Id of a given player. | | `format` | xml or json | | `your_api_key` | Your API key | ### Optional Query String Parameters >Example including optional query string parameters:
    require 'uri'
    require 'net/http'
    require 'openssl'
    
    url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/players/sr:player:1059961/schedules.xml?api_key={your_api_key}&start=0&limit=75")
    
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    
    request = Net::HTTP::Get.new(url)
    
    response = http.request(request)
    puts response.read_body
    
    import http.client
    
    conn = http.client.HTTPSConnection("api.sportradar.com")
    
    conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/players/sr:player:1059961/schedules.xml?api_key={your_api_key}&start=0&limit=75")
    
    res = conn.getresponse()
    data = res.read()
    
    print(data.decode("utf-8"))
    
    curl -L GET 'api.sportradar.com/soccer-advanced-analytics/trial/v1/en/players/sr:player:1059961/schedules.xml?api_key={your_api_key}&start=0&limit=75'
    
    In addition to the URL parameters listed above, you can paginate the player information with one or more of the following optional query string parameters.
    Note: Optional query string parameters must be added after your API key with an ampersand (&).
    Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `start` | Number to start the list of results from.
    Example: start=0 | | `limit` | Number to limit the number of results. Minimum value is 1, maximum value is 200.
    Example: limit=200 | Return to top ## Season Competitors Provides a list of teams participating for a given season.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competitor Info Data Points: Abbreviation
    Id
    Name
    Short Name
    Competitor Virtual
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/competitors.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/competitors.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/competitors.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Competitors feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/competitors.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Season Form Standings Provides a form table of game results and splits for a given season. Table displays W/D/L (win/draw/loss) for a maximum of 6 matches for each team.
    TTL / Cache: 60 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competition Info Data Points: Group Id Group Name
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Standings Data Points: Draws
    Form Standing Results
    Form Standing Type
    Goals Against
    Goal Difference
    Goals For
    Losses
    Played
    Points
    Rank
    Wins
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/form_standings.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/form_standings.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/form_standings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Standings feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/form_standings.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | ### Optional Query String Parameters >Example including optional query string parameters:
    require 'uri'
    require 'net/http'
    require 'openssl'
    
    url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/form_standings.xml?api_key={your_api_key}&limit=2")
    
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    
    request = Net::HTTP::Get.new(url)
    
    response = http.request(request)
    puts response.read_body
    
    import http.client
    
    conn = http.client.HTTPSConnection("api.sportradar.com")
    
    conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/form_standings.xml?api_key={your_api_key}&limit=2")
    
    res = conn.getresponse()
    data = res.read()
    
    print(data.decode("utf-8"))
    
    curl -L GET 'api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/form_standings.xml?api_key={your_api_key}&limit=2'
    
    In addition to the URL parameters listed above, you can filter the Standings information with the following optional query string parameter.
    Note: Optional query string parameters must be added after your API key with an ampersand (&). If you are filtering for more than one result, separate the results with a comma (,) and no spaces.
    Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `round` | Round number expressed as: {round}.
    Example: round=1 | | `limit` | Number of matches played to display for each team.
    Example: limit=2

    Note: The max limit is 10, which will show for example played=10, win=8, loss=2. But the form will always display a max of 6 matches. | Return to top ## Season Info Provides detailed information for a given season, including participating teams and coverage level
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Max Rounds
    Group Name
    Group Parent Group Id
    Info Competition Status
    Info Venue Changed
    Info Venue Reduced Capacity
    Info Venue Reduced Capacity Max
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Other Season Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Sport Event Info Data Points: Coverage Type
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/info.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/info.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/info.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Info feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/info.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Season Leaders Provides a list of leaders for a given season. Statistics include points, goals, assists, cards, and minutes played.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competitor Info Data Points: Competitor Abbreviation Competitor Id Competitor Name
    Player Info Data Points: Player Id Player Multiple Competitors Player Name
    Season Leader Info Data Points: List Type
    Leader Rank
    Datapoint Type Datapoint Value
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/leaders.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/leaders.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/leaders.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Leaders feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/leaders.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Season Lineups Provides match lineups and substitutions for a given season.
    TTL / Cache: 30 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Jersey Base Color
    Jersey Horizontal Stripes
    Jersey Horizontal Stripes Color
    Jersey Number Color
    Jersey Shirt Type
    Jersey Sleeve Color
    Jersey Sleeve Detail
    Jersey Split
    Jersey Split Color
    Jersey Squares
    Jersey Squares Color
    Jersey Stripes
    Jersey Stripes Color
    Jersey Type
    Manager Country Code
    Manager Date of Birth
    Manager Gender
    Manager Id
    Manager Name
    Manager Nationality
    Manager Nickname
    Manager Place of Birth
    Manager Preferred Foot
    Player Info Data Points: Country Code
    Date of Birth
    Gender
    Height
    Id
    Jersey Number
    Name
    Nationality
    Nickname
    Place of Birth
    Played
    Preferred Foot
    Starter
    Type
    Weight
    Sport Event Info Data Points: Attendance Count
    Channel Country
    Channel Name
    Channel URL
    Coverage Type
    Ground Neutral
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Lineups Confirmed
    Referee Id
    Referee Name
    Referee Nationality
    Referee Country Code
    Referee Type
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Weather Overall Conditions
    Weather Pitch Conditions
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation Qualifier
    Match Situation Status
    Match Situation Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Play by Play Info Data Points: Qualifier
    Order
    X Coordinate Y Coordinate
    Match Lineups Data Points: Player Order
    Player Position
    Team Designation Team Formation
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/lineups.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/lineups.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/lineups.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Lineups feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/lineups.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | ### Optional Query String Parameters >Example including optional query string parameters:
    require 'uri'
    require 'net/http'
    require 'openssl'
    
    url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/lineups.xml?api_key={your_api_key}&start=0&limit=75")
    
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    
    request = Net::HTTP::Get.new(url)
    
    response = http.request(request)
    puts response.read_body
    
    import http.client
    
    conn = http.client.HTTPSConnection("api.sportradar.com")
    
    conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/lineups.xml?api_key={your_api_key}&start=0&limit=75")
    
    res = conn.getresponse()
    data = res.read()
    
    print(data.decode("utf-8"))
    
    curl -L GET 'api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/lineups.xml?api_key={your_api_key}&start=0&limit=75'
    
    In addition to the URL parameters listed above, you can paginate the lineup information with one or more of the following optional query string parameters.
    Note: Optional query string parameters must be added after your API key with an ampersand (&).
    Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `start` | Number to start the list of results from.
    Example: start=0 | | `limit` | Number to limit the number of results. Minimum value is 1, suggested maximum value is 75.
    Example: limit=75 | Return to top ## Season Links Provides information about linked cup rounds for a given season. This feed can be used to compile advancement brackets for relevant seasons.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competition Info Data Points: Cup Round Id
    Cup Round Name
    Cup Round Order
    Cup Round State
    Cup Round Type
    Cup Round Winner Id
    Group - Group Name
    Group Id
    Stage End Date
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Sport Event Info Data Points: Sport Event Id
    Sport Event Replaced By
    Sport Event Start Time Sport Event Start Time Confirmed
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/stages_groups_cup_rounds.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/stages_groups_cup_rounds.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/stages_groups_cup_rounds.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Links feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/stages_groups_cup_rounds.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Season Missing Players Provides a list of injured and/or missing players for a given season.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competitor Info Data Points: Competitor Abbreviation Competitor Id Competitor Name
    Player Info Data Points: Id
    Missing Reason
    Missing Start Date
    Name
    Status
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/missing_players.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/missing_players.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/missing_players.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Missing Players feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/missing_players.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Season Over/Under Statistics Provides the over/under match goal totals for all teams in a given season.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competitor Info Data Points: Competitor Abbreviation Competitor Id Competitor Name
    Team Season Statistics Data Points: Over/Under List Type
    Over/Under - Goals
    Over/Under - Matches Over Over/Under - Matches Under
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/over_under_statistics.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/over_under_statistics.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/over_under_statistics.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Over/Under Statistics feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/over_under_statistics.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Season Players Provides names and ids for all participating players for a given season.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Player Info Data Points: Country Code
    Date of Birth
    Display First Name
    Display Last Name
    First Name
    Gender
    Height
    Id
    Jersey Number
    Last Name
    Name
    Nationality
    Nickname
    Type
    Weight
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/players.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/players.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/players.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Players feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/players.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ### Optional Query String Parameters >Example including optional query string parameters:
    require 'uri'
    require 'net/http'
    require 'openssl'
    
    url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/players.xml?api_key={your_api_key}&start=0&limit=75")
    
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    
    request = Net::HTTP::Get.new(url)
    
    response = http.request(request)
    puts response.read_body
    
    import http.client
    
    conn = http.client.HTTPSConnection("api.sportradar.com")
    
    conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/players.xml?api_key={your_api_key}&start=0&limit=75")
    
    res = conn.getresponse()
    data = res.read()
    
    print(data.decode("utf-8"))
    
    curl -L GET 'api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:89613/players.xml?api_key={your_api_key}&start=0&limit=75'
    
    In addition to the URL parameters listed above, you can paginate the player information with one or more of the following optional query string parameters.
    Note: Optional query string parameters must be added after your API key with an ampersand (&).
    Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `start` | Number to start the list of results from.
    Example: start=0 | | `limit` | Number to limit the number of results. Minimum value is 1, maximum value is 200.
    Example: limit=200 | Return to top ## Season Probabilities Provides 3-way win probabilities (home team win, away team win, draw) for all matches for a given season.
    TTL / Cache: 60 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Sport Event Info Data Points: Attendance Count
    Channel Country
    Channel Name
    Channel URL
    Coverage Type
    Ground Neutral
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Lineups Confirmed
    Referee Id
    Referee Name
    Referee Nationality
    Referee Country Code
    Referee Type
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Weather Overall Conditions
    Weather Pitch Conditions
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation Qualifier
    Match Situation Status
    Match Situation Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Play by Play Info Data Points: Qualifier
    Order
    X Coordinate Y Coordinate
    Match Probabilities Data Points: Away Team Win Probabilities
    Draw Probabilities
    Home Team Win Probabilities
    Market Name
    Outcome Name
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/probabilities.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/probabilities.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/probabilities.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Probabilities feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/probabilities.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | ### Optional Query String Parameters >Example including optional query string parameters:
    require 'uri'
    require 'net/http'
    require 'openssl'
    
    url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v4/en/seasons/sr:season:101055/probabilities.xml?api_key={your_api_key}&start=200")
    
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    
    request = Net::HTTP::Get.new(url)
    
    response = http.request(request)
    puts response.read_body
    
    import http.client
    
    conn = http.client.HTTPSConnection("api.sportradar.com")
    
    conn.request("GET", "/soccer-advanced-analytics/trial/v4/en/seasons/sr:season:101055/probabilities.xml?api_key={your_api_key}&start=200")
    
    res = conn.getresponse()
    data = res.read()
    
    print(data.decode("utf-8"))
    
    curl -L GET 'api.sportradar.com/soccer-advanced-analytics/trial/v4/en/seasons/sr:season:101055/probabilities.xml?api_key={your_api_key}&start=200'
    
    In addition to the URL parameters listed above, you can paginate the response with one or more of the following optional query string parameters.
    Note: Optional query string parameters must be added after your API key with an ampersand (&).
    Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `start` | Number to start the list of results from.
    Example: start=0 | | `limit` | Number to limit the number of results. Minimum value is 1, maximum value is 200.
    Example: limit=200 | Return to top ## Season Schedule Provides basic match information for all matches for a given season, including scoring and match coverage.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Sport Event Info Data Points: Coverage Type
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation Qualifier
    Match Situation Status
    Match Situation Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/schedules.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/schedules.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/schedules.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Schedule feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/schedules.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Season Standings Provides detailed standings info for a given season.
    TTL / Cache: 10 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competition Info Data Points: Group - Group Name
    Group Id
    Group Name
    Group Parent Group Id
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Form
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Standings Info Data Points: Change
    Current Outcome
    Draws
    Goals Against
    Goals Differential
    Goals For
    Group - Group Name
    Group Comment Text
    Group Id
    Group Live
    Group Name
    Losses
    Matches Played
    Points
    Points Draw
    Points Loss
    Points Per Game
    Points Win
    Rank
    Round
    Tie Break Rule
    Type
    Wins
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/standings.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/standings.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/standings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Standings feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/standings.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | ### Optional Query String Parameters >Example including optional query string parameters:
    require 'uri'
    require 'net/http'
    require 'openssl'
    
    url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/standings.xml?api_key={your_api_key}&round=1")
    
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    
    request = Net::HTTP::Get.new(url)
    
    response = http.request(request)
    puts response.read_body
    
    import http.client
    
    conn = http.client.HTTPSConnection("api.sportradar.com")
    
    conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/standings.xml?api_key={your_api_key}&round=1")
    
    res = conn.getresponse()
    data = res.read()
    
    print(data.decode("utf-8"))
    
    curl -L GET 'api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/standings.xml?api_key={your_api_key}&round=1'
    
    In addition to the URL parameters listed above, you can filter the Standings information with the following optional query string parameter.
    Note: Optional query string parameters must be added after your API key with an ampersand (&). If you are filtering for more than one result, separate the results with a comma (,) and no spaces.
    Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `round` | Round number expressed as: {round}.
    Example: round=1 | | `live` | Live standings expressed as a boolean value.
    Example: live=true | Return to top ## Season Transfers Provides a list of all player transfers for a given season.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Player Info Data Points: Country Code
    Date of Birth
    Gender
    Height
    Id
    Jersey Number
    Name
    Nationality
    Nickname
    Place of Birth Transfer Date
    Transfer From Competitor
    Transfer Role Type
    Transfer To Competitor
    Type
    Weight
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:83706/transfers.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:83706/transfers.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:83706/transfers.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Season Transfers feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/transfers.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Seasonal Competitor Players Provides player roster information for every team from a given season.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competitor Info Data Points: Abbreviation
    Id
    Name
    Short Name
    Virtual
    Player Info Data Points: Country Code
    Date of Birth
    Gender
    Height
    Id
    Jersey Number
    Name
    Nationality
    Nickname
    Place of Birth
    Preferred Foot
    Type
    Weight
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/competitor_players.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/competitor_players.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:101055/competitor_players.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Seasonal Competitor Players feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/competitor_players.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Seasonal Competitor Statistics Provides team and player seasonal statistics for a given season.
    TTL / Cache: 30 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Season Competition Id
    Season Disabled
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Compeittor Id
    Competitor Name
    Player Info Data Points: Id Name Starter
    Player Seasonal Statistics Data Points: Aerial Duels Defensive
    Aerial Duels Defensive Won
    Aerial Duels Offensive
    Aerial Duels Offensive Won
    Assists
    Assists by Free Kick
    Attempts at Goal Blocked
    Attempts at Goal Inside the Penalty Area
    Attempts at Goal Inside the Penalty Area on Target
    Attempts at Goal Inside the Penalty Area Scored
    Attempts at Goal Outside the Penalty Area
    Attempts at Goal Outside the Penalty Area on Target
    Attempts at Goal Outside the Penalty Area Scored
    Ball Progression
    Ball Progression Complete
    Ball Progression Incomplete
    Clearances
    Corners
    Corners Long
    Corners Short
    Crosses
    Crosses Completed
    Crosses Early
    Crosses High
    Crosses Incomplete
    Crosses Late
    Crosses Low
    Crosses to Attempt at Goal
    Crosses to Goal
    Direct Red Cards
    Diving Saves
    Duels Complete
    Duels Defensive
    Duels Defensive Opponents Half
    Duels Defensive Opponents Half Won
    Duels Defensive Own Box
    Duels Defensive Own Box Won
    Duels Defensive Own Half
    Duels Defensive Own Half Won
    Duels Defensive Won
    Duels Fifty Fifty
    Duels Incomplete
    Duels Offensive
    Deuls Offensive Won
    Duels Sliding
    Duels Total
    Events
    Events Inside Box
    Events Key
    Events Key Free Kick
    Events Successful
    Fouls Against
    Fouls For
    Fouls Own Half
    Free Kicks
    Free Kicks Missed
    Free Kicks on Goal
    Free Kicks Scored
    Goal Kicks
    Goals
    Goals Conceded
    Ground Duels Defensive
    Ground Duels Defensive Won
    Ground Duels Offensive
    Ground Duels Offensive Won
    Interceptions Goalkeeper
    Keeper Throws Long
    Keeper Throws Short
    Minutes Played
    Offsides
    Own Goals
    Passes
    Passes Backward
    Passes Backward Complete
    Passes Between Central Defenders
    Passes Complete
    Passes Direct
    Passes First in Possession
    Passes First in Possession Forward
    Passes Forward
    Passes Forward Complete
    Passes in Final Third
    Passes in Final Third Complete
    Passes Incomplete
    Passes Into Box
    Passes Key
    Passes Long
    Passes Long Complete
    Passes Long Incomplete
    Passes Opponents Half
    Passes Opponents Half Complete
    Passes Own Half
    Passes Short
    Passes Switch
    Passes Wide
    Passes Wide Complete
    Penalties Faced
    Penalties Saved
    Possession Opponents Half
    Possessions Lost
    Possessions Lost by Duel
    Possessions Lost by Passes
    Possessions Regained by Duel
    Possessions Regained by Interception
    Possessions Regained in Opponents Half
    Possessions Time
    Red Cards for Second Caution
    Throw-ins
    Throw-ins Keep Possession
    Yellow Cards
    Team Seasonal Statistics Data Points: Aerial Duels Defensive
    Aerial Duels Defensive Won
    Aerial Duels Offensive
    Aerial Duels Offensive Won
    Assists by Free Kick
    Attempts at Goal Blocked
    Attempts at Goal Inside the Penalty Area
    Attempts at Goal Inside the Penalty Area on Target
    Attempts at Goal Inside the Penalty Area Scored
    Attempts at Goal on Target
    Attempts at Goal Outside the Penalty Area
    Attempts at Goal Outside the Penalty Area on Target
    Attempts at Goal Outside the Penalty Area Scored
    Attempts on Target Saves
    Ball Progression
    Ball Progression Complete
    Ball Progression Incomplete
    Clearances
    Corners
    Corners Long
    Corners Short
    Crosses
    Crosses Completed
    Crosses Early
    Crosses High
    Crosses Incomplete
    Crosses Late
    Crosses Low
    Crosses to Attempt at Goal
    Crosses to Goal
    Direct Red Cards
    Duels Complete
    Duels Defensive
    Duels Defensive Opponents Half
    Duels Defensive Opponents Half Won
    Duels Defensive Own Box
    Duels Defensive Own Box Won
    Duels Defensive Own Half
    Duels Defensive Own Half Won
    Duels Defensive Won
    Duels Fifty Fifty
    Duels Incomplete
    Duels Offensive
    Deuls Offensive Won
    Duels Sliding
    Duels Total
    Events
    Events Inside Box
    Events Key
    Events Key Free Kick
    Events Successful
    Fouls Against
    Fouls For
    Fouls Own Half
    Free Kicks
    Free Kicks Missed
    Free Kicks on Goal
    Free Kicks Scored
    Goal Kicks
    Goals Conceded
    Ground Duels Defensive
    Ground Duels Defensive Won
    Ground Duels Offensive
    Ground Duels Offensive Won
    Interceptions Goalkeeper
    Keeper Throws Long
    Keeper Throws Short
    Offsides
    Passes
    Passes Backward
    Passes Backward Complete
    Passes Between Central Defenders
    Passes Complete
    Passes Direct
    Passes First in Possession
    Passes First in Possession Forward
    Passes Forward
    Passes Forward Complete
    Passes in Final Third
    Passes in Final Third Complete
    Passes Incomplete
    Passes Into Box
    Passes Key
    Passes Long
    Passes Long Complete
    Passes Long Incomplete
    Passes Opponents Half
    Passes Opponents Half Complete
    Passes Own Half
    Passes Short
    Passes Switch
    Passes Wide
    Passes Wide Complete
    Possession Opponents Half
    Possessions Lost
    Possessions Lost by Duel
    Possessions Lost by Passes
    Possessions Regained by Duel
    Possessions Regained by Interception
    Possessions Regained in Opponents Half
    Possessions Regained in Play
    Possessions Regained in Play Own Half
    Possessions Time
    Red Cards for Second Caution
    Speed of Play
    Throw-ins
    Throw-ins Keep Possession
    Yellow Cards
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:54571/competitors/sr:competitor:17/statistics.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:54571/competitors/sr:competitor:17/statistics.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons/sr:season:54571/competitors/sr:competitor:17/statistics.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Seasonal Competitor Statistics feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/competitors/`{competitor_id}`/statistics.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `season_id` | Id of a given season. | | `competitor_id` | Id of a given competitor | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Seasons Provides a complete list of historical season information for all supported competitions in the API.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Competition Info Data Points: Season Competition Id
    Season Disabled
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Year
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/soccer/trial/v1/en/seasons.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/seasons.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Seasons feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/seasons.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Sport Event Fun Facts Provides noteworthy, human-readable, facts based on statistical information about a given match and its competing teams.
    TTL / Cache: 300 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport Event Info Data Points: Match Facts
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/fun_facts.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/fun_facts.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/fun_facts.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Sport Event Fun Facts feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{sport_event_id}`/fun_facts.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `sport_event_id` | Id of a given sport event | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Sport Event Lineups Provides detailed roster information for a given match. Starting players, substitutions, formation type, and channel availability are included if supported by coverage level.
    TTL / Cache: 1 second
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Jersey Base Color
    Jersey Horizontal Stripes
    Jersey Horizontal Stripes Color
    Jersey Number Color
    Jersey Shirt Type
    Jersey Sleeve Color
    Jersey Sleeve Detail
    Jersey Split
    Jersey Split Color
    Jersey Squares
    Jersey Squares Color
    Jersey Stripes
    Jersey Stripes Color
    Jersey Type
    Manager Country Code
    Manager Date of Birth
    Manager Gender
    Manager Id
    Manager Name
    Manager Nationality
    Manager Nickname
    Manager Place of Birth
    Manager Preferred Foot
    Player Info Data Points: Country Code
    Date of Birth
    Gender
    Height
    Id
    Jersey Number
    Name
    Nationality
    Nickname
    Place of Birth
    Played
    Preferred Foot
    Starter
    Type
    Weight
    Sport Event Info Data Points: Attendance Count
    Channel Country
    Channel Name
    Channel URL
    Coverage Type
    Ground Neutral
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Lineups Confirmed
    Referee Id
    Referee Name
    Referee Nationality
    Referee Country Code
    Referee Type
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Weather Overall Conditions
    Weather Pitch Conditions
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation Qualifier
    Match Situation Status
    Match Situation Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Play by Play Info Data Points: Qualifier
    Order
    X Coordinate Y Coordinate
    Match Lineups Data Points: Player Order
    Player Position
    Team Designation Team Formation
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/lineups.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/lineups.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/lineups.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Sport Event Lineups feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{sport_event_id}`/lineups.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `sport_event_id` | Id of a given sport event | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Sport Event Summary Provides real-time advanced analytic statistics for a given match. Including player and team stats, scoring info, and channel availability. Please note that data returned is determined by coverage level.
    TTL / Cache: 1 second
    Update Frequency: Realtime
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Player Info Data Points: Id
    Name
    Starter Type
    Sport Event Info Data Points: Attendance Count
    Channel Country
    Channel Name
    Channel URL
    Coverage Type
    Ground Neutral
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Lineups Confirmed
    Referee Id
    Referee Name
    Referee Nationality
    Referee Country Code
    Referee Type
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Weather Overall Conditions
    Weather Pitch Conditions
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation Qualifier
    Match Situation Status
    Match Situation Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Play by Play Info Data Points: Qualifier
    Order
    X Coordinate Y Coordinate
    Match Statistics - Player: Aerial Duels Defensive
    Aerial Duels Defensive Won
    Aerial Duels Offensive
    Aerial Duels Offensive Won
    Assists
    Assists by Free Kick
    Attempts at Goal Blocked
    Attempts at Goal Inside the Penalty Area
    Attempts at Goal Inside the Penalty Area on Target
    Attempts at Goal Inside the Penalty Area Scored
    Attempts at Goal on Target
    Attempts at Goal Outside the Penalty Area
    Attempts at Goal Outside the Penalty Area on Target
    Attempts at Goal Outside the Penalty Area Scored
    Attempts on Target Saves
    Ball Progression
    Ball Progression Complete
    Ball Progression Incomplete
    Clearances
    Corners
    Corners Long
    Corners Short
    Crosses
    Crosses Completed
    Crosses Early
    Crosses High
    Crosses Incomplete
    Crosses Late
    Crosses Low
    Crosses to Attempt at Goal
    Crosses to Goal
    Direct Red Cards
    Duels Completed
    Duels Defensive
    Duels Defensive Opponents Half
    Duels Defensive Opponents Half Won
    Duels Defensive Own Box
    Duels Defensive Own Box Won
    Duels Defensive Own Half
    Duels Defensive Own Half Won
    Duels Defensive Won
    Duels Fifty Fifty
    Duels Incomplete
    Duels Offensive
    Duels Offensive Won
    Duels Sliding
    Duels Total
    Events
    Events Inside Box
    Events Key
    Events Key Corner
    Events Key Freekick
    Events Successful
    Fouls Against
    Fouls For
    Fouls Own Half
    Free Kicks
    Free Kicks Missed
    Free Kicks on Goal
    Free Kicks Scored
    Goal Kicks
    Goals Conceded
    Grade
    Ground Duels Defensive
    Ground Duels Defensive Won
    Ground Duels Offensive
    Ground Duels Offensive Won
    Interceptions Goalkeeper
    Involvement in Attempt at Goal
    Involvement in Attempt at Goal xG
    Keeper Throws Long
    Keeper Throws Short
    Minutes Played
    Offsides
    Passes
    Passes Backward
    Passes Backward Complete
    Passes Between Central Defenders
    Passes Complete
    Passes Direct
    Passes First in Possession
    Passes First in Possession Forward
    Passes Forward
    Passes Forward Complete
    Passes in Final Third
    Passes in Final Third Complete
    Passes Incomplete
    Passes into Box
    Passes Key
    Passes Long
    Passes Long Complete
    Passes Long Incomplete
    Passes Opponents Half
    Passes Opponents Half Complete
    Passes Own Half
    Passes Short
    Passes Switch
    Passes Wide
    Passes Wide Complete
    Possession Opponents Half
    Possesssions Lost
    Possessions Lost by Duel
    Possessions Lost by Passes
    Possessions Regained by Duel
    Possessions Regained by Interception
    Possessions Regained in Opponents Half
    Possessions Regained in Play
    Possessions Regained in Play Own Half
    Possessions Time
    Red Cards for Second Caution
    Speed of Play
    Throw Ins
    Throw Ins Keep Possession
    Total X Location
    Total Y Location
    xG Value
    Yellow Cards
    Match Statistics - Team: Aerial Duels Defensive
    Aerial Duels Defensive Won
    Aerial Duels Offensive
    Aerial Duels Offensive Won
    Assists by Free Kick
    Attempts at Goal Blocked
    Attempts at Goal Inside the Penalty Area
    Attempts at Goal Inside the Penalty Area on Target
    Attempts at Goal Inside the Penalty Area Scored
    Attempts at Goal on Target
    Attempts at Goal Outside the Penalty Area
    Attempts at Goal Outside the Penalty Area on Target
    Attempts at Goal Outside the Penalty Area Scored
    Attempts on Target Saves
    Ball Progression
    Ball Progression Complete
    Ball Progression Incomplete
    Clearances
    Corners
    Corners Long
    Corners Short
    Crosses
    Crosses Completed
    Crosses Early
    Crosses High
    Crosses Incomplete
    Crosses Late
    Crosses Low
    Crosses to Attempt at Goal
    Crosses to Goal
    Direct Red Cards
    Duels Completed
    Duels Defensive
    Duels Defensive Opponents Half
    Duels Defensive Opponents Half Won
    Duels Defensive Own Box
    Duels Defensive Own Box Won
    Duels Defensive Own Half
    Duels Defensive Own Half Won
    Duels Defensive Won
    Duels Fifty Fifty
    Duels Incomplete
    Duels Offensive
    Duels Offensive Won
    Duels Sliding
    Duels Total
    Events
    Events Inside Box
    Events Key
    Events Key Corner
    Events Key Freekick
    Events Successful
    Fouls Against
    Fouls For
    Fouls Own Half
    Free Kicks
    Free Kicks Missed
    Free Kicks on Goal
    Free Kicks Scored
    Goal Kicks
    Ground Duels Defensive
    Ground Duels Defensive Won
    Ground Duels Offensive
    Ground Duels Offensive Won
    Interceptions Goalkeeper
    Involvement in Attempt at Goal
    Involvement in Attempt at Goal xG
    Keeper Throws Long
    Keeper Throws Short
    Offsides
    Passes
    Passes Backward
    Passes Backward Complete
    Passes Between Central Defenders
    Passes Complete
    Passes Direct
    Passes First in Possession
    Passes First in Possession Forward
    Passes Forward
    Passes Forward Complete
    Passes in Final Third
    Passes in Final Third Complete
    Passes Incomplete
    Passes into Box
    Passes Key
    Passes Long
    Passes Long Complete
    Passes Long Incomplete
    Passes Opponents Half
    Passes Opponents Half Complete
    Passes Own Half
    Passes Short
    Passes Switch
    Passes Wide
    Passes Wide Complete
    Possession Opponents Half
    Possesssions Lost
    Possessions Lost by Duel
    Possessions Lost by Passes
    Possessions Regained by Duel
    Possessions Regained by Interception
    Possessions Regained in Opponents Half
    Possessions Regained in Play
    Possessions Regained in Play Own Half
    Possessions Time
    Red Cards for Second Caution
    Speed of Play
    Throw Ins
    Throw Ins Keep Possession
    Total X Location
    Total Y Location
    xG Value
    Yellow Cards
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/summary.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/summary.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/summary.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Sport Event Summary feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{sport_event_id}`/summary.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `sport_event_id` | Id of a given sport event | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Sport Event Timeline Provides real-time advanced analytic events and a play-by-play event timeline for a given match. Please note that data returned is determined by coverage level.
    TTL / Cache: 1 second
    Update Frequency: Realtime
    Content Type: XML or JSON
    Sport & Category Info Data Points: Category Country Code
    Category Id
    Category Name
    Sport Id
    Sport Name
    Competition Info Data Points: Competition Gender
    Competition Id
    Competition Name
    Competition Parent Id
    Competition Properties Brackets
    Competition Properties Missing Players
    Competition Properties Player Transfer History
    Competition Properties Schedules
    Competition Properties Season Player Statistics
    Competition Properties Season Probabilities
    Competition Properties Season Stats Leaders
    Competition Properties Season Team Statistics
    Competition Properties Standings
    Competition Properties Team Squads
    Group Group Name
    Group Id
    Group Name
    Round Cup Round Number of Sport Events
    Round Cup Round Sport Event Number
    Round Name
    Round Number
    Round Other Sport Event Id
    Season End Date
    Season Id
    Season Name
    Season Start Date
    Season Competition Id
    Season Year
    Stage End Date
    Stage Order
    Stage Phase
    Stage Start Date
    Stage Type
    Stage Year
    Competitor Info Data Points: Competitor Abbreviation
    Competitor Age Group
    Competitor Country
    Competitor Country Code
    Competitor Gender
    Competitor Id
    Competitor Name
    Competitor Qualifier
    Competitor Virtual
    Player Info Data Points: Id Name Type
    Sport Event Info Data Points: Attendance Count
    Channel Country
    Channel Name
    Channel URL
    Coverage Type
    Ground Neutral
    Group Properties Brackets
    Group Properties Cup
    Group Properties Group Stage
    Group Properties League
    Group Properties Missing Players
    Group Properties Qualification
    Group Properties Results
    Group Properties Schedules
    Group Properties Standings
    Lineups Confirmed
    Referee Id
    Referee Name
    Referee Nationality
    Referee Country Code
    Referee Type
    Sport Event Id
    Sport Event Replaced By
    Sport Event Resume Time
    Sport Event Start Time
    Sport Event Start Time Confirmed
    Sport Event Properties
    Sport Event Properties Advanced Data
    Sport Event Properties Ballspotting
    Sport Event Properties Basic Play-by-Play
    Sport Event Properties Basic Player Stats
    Sport Event Properties Basic Team Stats
    Sport Event Properties Commentary
    Sport Event Properties Deeper Play-by-Play
    Sport Event Properties Deeper Player Stats
    Sport Event Properties Deeper Team Stats
    Sport Event Properties Fun Facts
    Sport Event Properties Game Clock
    Sport Event Properties Goal Scorers
    Sport Event Properties Lineups
    Sport Event Properties Lineups Availability
    Sport Event Properties Probabilities
    Sport Event Properties Scores
    Sport Event Properties Venue
    Weather Overall Conditions
    Weather Pitch Conditions
    Boxscore Info Data Points: Clock Played
    Clock Stoppage Time Announced
    Clock Stoppage Time Played
    Match Situation Qualifier
    Match Situation Status
    Match Situation Updated At
    Period Score Away Score
    Period Score Home Score
    Period Score Number
    Period Score Type
    Sport Event Status Aggregate Away Score
    Sport Event Status Aggregate Home Score
    Sport Event Status Aggregate Winner Id
    Sport Event Status Away Normaltime Score
    Sport Event Status Away Overtime Score
    Sport Event Status Away Score
    Sport Event Status Decided by Fed
    Sport Event Status Home Normaltime Score
    Sport Event Status Home Overtime Score
    Sport Event Status Home Score
    Sport Event Status Match Status
    Sport Event Status Match Tie
    Sport Event Status Scout Abandoned
    Sport Event Status Status
    Sport Event Status Winner Id
    Play by Play Info Data Points: Away Team Score
    Ball Location Qualifier
    Ball Location Order
    Ball Location X Coordinate
    Ball Location Y Coordinate
    Event Block Type
    Event Break Name
    Event Card Description
    Event Clearance Body
    EVent Clearance Type
    Event Commentary
    Event Competitor
    Event Control Type
    Event Coordinate X
    Event Coordinate Y
    Event Cross Body
    Event Cross is Assist
    Event Cross Style
    Event Description
    Event Duel Result
    Event Duel Type
    Event Id
    Event Injury Time Announced
    Event Match Clock
    Event Match Time
    Event Method
    Event Outcome
    Event Pass Body
    Event Pass is Assist
    Event Pass Outcome
    Event Period
    Event Period Name
    Event Period Type
    Event Save is Successful
    Event Save Type
    Event Shootout Away Score
    Event Shootout Home Score
    Event Status
    Event Stoppage Time
    Event Stoppage Time Clock
    Event Type
    Event Time
    Event Updated
    Event Updated Time
    Home Team Score
    Play Details Data Points: Assisting Player Id
    Assisting Player Method
    Assisting Player Name
    Assisting Player Type
    Goal Scorer Id
    Goal Scorer Method
    Goal Scorer Name
    Goal Scorer Type
    Substitution Player In Id
    Substitution Player In Method
    Substitution Player In Name
    Substitution Player In Type
    Substitution Player Out Id
    Substitution Player Out Method
    Substitution Player Out Name
    Substitution Player Out Type
    Venue Info Data Points: Capacity
    Changed
    City
    Country
    Country Code
    Id
    Map Coordinates
    Name
    Reduced Capacity
    Reduced Capacity Max
    Timezone
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/timeline.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/timeline.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/sr:sport_event:37098941/timeline.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Sport Event Timeline feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{sport_event_id}`/timeline.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `sport_event_id` | Id of a given sport event | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Sport Events Created Provides Ids for sport events that have been created in the last 24 hours.
    Note: Pagination will often be required to pull all data within this feed. By default, the feed will return 200 sport events.
    TTL / Cache: 60 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport Event Info Data Points: Active Season Flag Id Created At
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/created.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/sport_events/created.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/created.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `format` | xml or json | | `your_api_key` | Your API key | ### Optional Query String Parameters >Example including optional query string parameters:
    require 'uri'
    require 'net/http'
    require 'openssl'
    
    url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/created.xml?api_key={your_api_key}&start=0&limit=75")
    
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    
    request = Net::HTTP::Get.new(url)
    
    response = http.request(request)
    puts response.read_body
    
    import http.client
    
    conn = http.client.HTTPSConnection("api.sportradar.com")
    
    conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/sport_events/created.xml?api_key={your_api_key}&start=0&limit=75")
    
    res = conn.getresponse()
    data = res.read()
    
    print(data.decode("utf-8"))
    
    curl -L GET 'api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/created.xml?api_key={your_api_key}&start=0&limit=75'
    
    In addition to the URL parameters listed above, you can paginate the response with one or more of the following optional query string parameters. This will often be required to access all available data in this feed.
    Note: Optional query string parameters must be added after your API key with an ampersand (&).
    Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `start` | Number to start the list of results from.
    Example: start=0 | | `limit` | Number to limit the number of results. Minimum value is 1, maximum value is 200.
    Example: limit=200 | Return to top ## Sport Events Removed Provides ids for sport events that have been removed from the API due to an entry error. Ids will remain in the response for 2 weeks.
    TTL / Cache: 60 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport Event Info Data Points: Sport Event Removed Id Sport Event Removed Replaced By
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/removed.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/sport_events/removed.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/removed.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Sport Events Removed feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/sport_events/removed.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `format` | xml or json | | `your_api_key` | Your API key | Return to top ## Sport Events Updated Provides Ids for sport events that have been updated in the last 24 hours.
    TTL / Cache: 60 seconds
    Update Frequency: As Necessary
    Content Type: XML or JSON
    Sport Event Info Data Points: Sport Event Updated Id Sport Event Updated - Updated At
    ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/updated.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.com") conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/sport_events/updated.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/updated.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Sport Events Updated feed by replacing the parameters in the following URL: https://api.sportradar.com/soccer-advanced-analytics/`{access_level}`/`{version}`/`{language_code}`/sport_events/updated.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial) | | `version` | Version number of the API you are accessing (Current Version: v1) | | `language_code` | 2 letter code for supported languages

    Chinese - simplified (zh), Chinese - traditional (zht), Danish (da), Dutch (nl), English (en), Finnish (fi), French (fr), German (de), Greek (el), Hindi (hi), Indonesian (id), Italian (it), Japanese (ja), Portuguese (pt), Russian (ru), Serbian (sr), Serbian Latin (srl), Spanish (es), Thai (th), Turkish (tr)

    Click here for a tabular list of available languages per competition. | | `format` | xml or json | | `your_api_key` | Your API key | ### Optional Query String Parameters >Example including optional query string parameters:
    require 'uri'
    require 'net/http'
    require 'openssl'
    
    url = URI("https://api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/updated.xml?api_key={your_api_key}&start=0&limit=75")
    
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    
    request = Net::HTTP::Get.new(url)
    
    response = http.request(request)
    puts response.read_body
    
    import http.client
    
    conn = http.client.HTTPSConnection("api.sportradar.com")
    
    conn.request("GET", "/soccer-advanced-analytics/trial/v1/en/sport_events/updated.xml?api_key={your_api_key}&start=0&limit=75")
    
    res = conn.getresponse()
    data = res.read()
    
    print(data.decode("utf-8"))
    
    curl -L GET 'api.sportradar.com/soccer-advanced-analytics/trial/v1/en/sport_events/updated.xml?api_key={your_api_key}&start=0&limit=75'
    
    In addition to the URL parameters listed above, you can paginate the event information with one or more of the following optional query string parameters.
    Note: Optional query string parameters must be added after your API key with an ampersand (&).
    Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `start` | Number to start the list of results from.
    Example: start=0 | | `limit` | Number to limit the number of results. Minimum value is 1, maximum value is 200.
    Example: limit=200 | Return to top ## Frequently Asked Questions Q: What leagues or tournaments do you cover for soccer?

    A: You can find all the leagues we cover, as well as a breakdown of advanced analytics offered, via our Coverage Matrix.

    Q: Are simulations available for Soccer Advanced Analytics?

    A: Simulations for Soccer Advanced Analytics are not currently available.

    Q: How are friendlies handled in the Summary feeds?

    A: The Summary feeds will return all Friendlies that have been played the last two weeks and that will be played the next 4 weeks.

    Q: What is the Date format?

    A: When we present date only values we present these in the ISO 8601 standard format.
    ex: 2013-04-03
    We use these for attributes that have date and no time (such as birthdate). For more information: https://en.wikipedia.org/wiki/ISO_8601

    Q: What time zone are the date time fields presented in?

    A: All of our Date/Time attributes are in UTC, presented in the ISO 8601 standard format.
    ex: 2013-04-03T18:15:00+00:00
    For more information: https://en.wikipedia.org/wiki/ISO_8601

    Q: When is coverage information added to the feeds?

    A: On the first day of the season.

    Q: How can I find the values for various enum data points within the API?

    A: Many enum values are listed in the FAQ below. For the most up-to-date values, please see the Schema section of the OpenAPI specification here: https://schemas.sportradar.com/sportsapi/soccer-advanced-analytics/v1/openapi/swagger/index.html

    Q: What are the valid sport_event_status – status values?

    A: Here are the valid status values and their definitions:

    • not_started – The match is scheduled to be played
    • started - The match has begun
    • live – The match is currently in progress
    • postponed – The match has been postponed to a future date
    • suspended - The match has been suspended
    • match_about_to_start - The match is about to begin
    • delayed – The match has been temporarily delayed and will be continued
    • interrupted - The match began, but coverage has stopped for a short time. Note that match scores may not be updated during this period, the last recorded match score will be displayed instead
    • cancelled – The match has been cancelled and will not be played
    • ended – The match is over
    • closed – The match results have been confirmed

    Q: What are the valid sport_event_status – match_status values?

    A: Here are the valid match status values and their definitions:

    • not_started – The match is scheduled to be played
    • started - The match has begun
    • 1st_half – The match is in the first half
    • 2nd_half – The match is in the second half
    • overtime – The match is in overtime
    • 1st_extra – The match is in the first extra period
    • 2nd_extra – The match is in the second extra period
    • awaiting_penalties – Waiting for announcement of penalties
    • penalties – Penalties are ongoing
    • awaiting_extra_time – Waiting on referee to announce extra time
    • interrupted – The match has been interrupted
    • abandoned – The match has been abandoned
    • postponed – The match has been postponed to a future date
    • start_delayed – The match has been temporarily delayed and will be continued
    • cancelled – The match has been cancelled and will not be played
    • halftime – The match is in halftime
    • extra_time_halftime – The match is in extra time halftime
    • ended – The match has ended
    • aet – The match has ended after extra time
    • ap – The match has ended after penalties

    Q: What are the valid period type and period name values for events?

    A: Here are the valid period name and period type values:

    • regular_period
    • overtime
    • penalties
    • interrupted

    Q: What are the valid lineup types (player position) values?

    A: Here are the valid lineup type

    • goalkeeper
    • defender
    • midfielder
    • forward

    Q: What are the valid lineups descriptions (player tactical position) values?

    A: Here are the valid lineups descriptions:

    • goalkeeper
    • right back
    • central defender
    • left back
    • right winger
    • central midfielder
    • left winger
    • striker

    Q: What are the valid current outcome values?

    A: Here are the valid current outcome types

    • AFC Champions League
    • AFC Cup
    • CAF Confederation Cup
    • Champions League
    • Champions League Qualification
    • Champions Round
    • Championship Round
    • Club Championship
    • Conference League Qualification
    • Copa Libertadores
    • Copa Libertadores Qualification
    • Copa Sudamericana
    • Cup Winners
    • Eliminated
    • Europa League
    • Europa League Qualification
    • European Cup
    • Final Four
    • Final Round
    • Finals
    • Group Matches
    • International Competition
    • Main Round
    • Next Group Phase
    • Placement Matches
    • Playoffs
    • Preliminary Round
    • Promotion
    • Promotion Playoff
    • Promotion Playoffs
    • Promotion Round
    • Qualification Playoffs
    • Qualified
    • Qualifying Round
    • Relegation
    • Relegation Playoff
    • Relegation Playoffs
    • Relegation Round
    • Semifinal
    • Top Six
    • UEFA Cup
    • UEFA Cup Qualification
    • UEFA Intertoto Cup

    Q: How do I find out the coverage for a particular match?

    A: Within the Schedules, Summaries, Lineups, and Timeline feeds, find the node for “coverage”. Coverage nodes have three types: season level, group level, and sport_event level.

    • The season level describes data coverage you can expect for matches involved in that given season.
    • The group level is similar because there exists competitions where coverage levels differ at different stages or in different groups - mostly cup competitions.
    • The sport_event level, this exists to describe the data depth of a specific match within the group and season.

    Note: There are occasions when the sport_event coverage can vary from the anticipated season coverage and this node exists to highlight that in that event to assist in handling any discrepancies.

    Q: How is coverage for a particular match defined?

    A: The coverage nodes contain classifications of data types which are expressed as Boolean values or denoted as “live” or “post”, for example: advanced_data="true" ballspotting="true" commentary="true" fun_facts="true" goal_scorers="true" scores="live" basic_play_by_play="true" basic_player_stats="true" basic_team_stats="true" lineups="true" deeper_player_stats="true" deeper_team_stats="true".

    Q: What are the possible pitch values?

    A: Here are the possible pitch values:

    • good
    • medium
    • bad

    Q: What are the possible weather conditions?

    A: Here are the possible weather conditions:

    • indoor
    • good
    • medium
    • bad
    • extreme

    Q: What are the possible event types?

    A: Here are all of the possible event types we log:

    • break_start
    • canceled_decision_to_var
    • corner_kick
    • decision_to_var
    • decision_to_var_over
    • free_kick
    • goal_kick
    • injury
    • injury_return
    • injury_time_shown
    • match_ended
    • match_started
    • offside
    • penalty_awarded
    • penalty_kick
    • penalty_missed
    • penalty_shootout
    • period_score
    • period_start
    • player_back_from_injury
    • possible_decision_to_var
    • red_card
    • save
    • score_change
    • shot_off_target
    • shot_on_target
    • shot_saved
    • substitution
    • throw_in
    • video_assistant_referee
    • video_assistant_referee_over
    • yellow_card
    • yellow_red_card

    * Availability of Video Assistant Referee is subject to the VAR capabilities of the league.

    Q: How does the possible_goal event type work?

    A: This event will occur immediately if one team scores a goal or if they are in a very clear scoring opportunity (1on1 with the goalkeeper, clear shot at an empty net, etc).

    Q: When video assistant referee reviews an event, what are the possible values for “event – outcome”?

    A: Here are the valid values:

    • goal
    • penalty
    • red_card
    • no_red_card
    • no_penalty
    • no_goal

    Q: What are the possible values for video assistant referee over?

    A: Here are the valid values:

    • call_stands
    • call_overturned

    Q: What is the scale of the X Y coordinates?

    A: The pitch we use is 100 by 100. Here is a layout of the pitch:
    0,0 X 100,0
    Y 50,50
    0,100 100,100

    X = Horizontal position on the pitch. X is a number between 0 and 100. The reference point 0 is at the home team’s goal.

    Y = Vertical position on the pitch. Y is a number between 0 and 100. The reference point 0 is on the top of the pitch where the home team’s goal is on the left hand side.

    Q: What are the possible values for referee_assistant type?

    A: Here are the valid referee assistant types:

    • first_assistant_referee
    • second_assistant_referee
    • fourth_official
    • video_assistant_referee
    • first_additional_assistant
    • second_additional_assistant
    • third_additional_assistant

    Q: How does the ball location attribute work?

    A: Our scouts mark down the x (lateral) and y (longitudinal) coordinates as observed on the pitch. The data can come in sporadically as events on the field play out, but new ball_location data is potentially available every 1 sec. This is only available for matches with ballspotting="true". The element ball_locations stores the last four known ball locations, after which the data is not available unless it corresponds with another event in the timeline such as throw_in, shot_on_goal etc. The ball_location order illustrates the most recent location as 4 and the oldest location as 1.

    Q: What are markets and what are the different markets?

    A: Markets is something you can bet on that we provide probabilities for. Over time we intend to provide more and more markets in the API. Currently the only market we provide is 3-way (will the home team win? Or the away team? Or will it be a draw?).

    Q: What are the possible outcomes?

    A: Different markets have different outcomes. The available markets are currently:

    • home_team_winner
    • away_team_winner
    • draw

    Q: When are fun facts added to the Sport Event Fun Facts feed?

    A: Fun facts appear in the feed starting 7 days before a match and are available for a fixed amount of time (14 days typically).

    Q: How is the order value in the Lineups feed organized?

    A: Order number 1 is always the goalie (star marking) and formations as well as numbering should start with the goalkeeper. In the example diagram the formation 4-2-3-1 is used.

    4 is the number of players in the line in front of the goalkeeper, then comes the line with 2 players and so on. Numbering in every line starts at the right-hand side of the goalkeeper – this causes the numbering to be mirrored for home and away team.

    Q: What are the possible reasons for a player to appear in the Missing Players feed?

    A: Listed below are the reasons why a player may appear in the missing players feed:

    • injured
    • ill
    • other
    • suspension

    Q: What are the possible values for stage – phase in the feeds?

    A: Listed below are the values for phase:

    • 1st_part_of_season_1st_leg
    • 2nd_part_of_season_2nd_leg
    • 3rd_round
    • champions_round
    • conference
    • division
    • final_eight
    • final_four
    • final_phase
    • final_round
    • final_stage
    • grand_final
    • grand_finals
    • group_phase_1
    • group_phase_2
    • knockout_stage
    • main_round_1
    • main_round_2
    • none
    • placement_matches
    • placement_matches_13_to_16
    • placement_matches_5_to_8
    • placement_matches_9_to_12
    • placement_matches_9_to_16
    • playoffs
    • playout
    • pre-season
    • preliminary_round
    • president_cup
    • promotion_playoffs
    • promotion_round
    • qualification
    • qualification_playoffs
    • qualification_to_allsvenskan
    • regular season
    • relegation_playoffs
    • relegation_promotion
    • relegation_promotion_round
    • relegation_round
    • stage_1
    • stage_1 no_stats
    • stage_2
    • stage_2 no_stats
    • stage_3
    • uefa_europa_league_playoffs

    Q: How long is full match data available for matches in the API?

    A: Match data is archived after one year and you will only be able to service basic score information from the API feeds. A historical statistics API for Soccer is on the roadmap, but no ETA is available at this time.

    Q: What are the possible values for event – time_description in the feeds?

    A: Listed below are some of the values for time descriptions on yellow/red cards.

    • pre_match
    • half_time
    • post_match

    Q: What are the possible values for list – type in the leaders feeds?

    A: Listed below are the values for list - type. Note: Not all values may be available for each season, based on the coverage available for that season.

    • points
    • goals
    • assists
    • red_cards
    • yellow_cards
    • yellow_red_cards
    • own_goals
    • shots_on_target
    • shots_off_target
    • goals_by_head
    • goals_by_penalty
    • clearances
    • interceptions
    • chances_created
    • crosses_successful
    • passes_successful
    • long_passes_successful
    • tackles_successful
    • clean_sheets
    • penalties_saved
    • dribbles_completed
    • loss_of_possession
    • minutes_played

    Q: What are the possible values for event – card_description in the timeline feeds?

    A: Listed below are the values for event – card_description.

    • pre_match
    • half_time
    • post_match
    • player_on_bench
    • first_half
    • second_half
    • during_penalty_shootout

    Q: Why does the coverage of past seasons not match the data in the feeds?

    A: Coverage properties are set at a competition level and only reflect the current or last season of that competition. Previous seasons may have greater or lesser coverage.

    Q: When does the Lineups Availability update in the feeds?

    A: The lineups_availability data is updated 30 days before the sport event is scheduled to begin.

    Q: What are the possible values for sport_event_properties – lineups_availability in the summary and timeline feeds?

    A: Listed below are the values for sport_event_properties – lineups_availability:

    • pre
    • post

    Q: How do you define basic and deeper play by play in terms of coverage?

    A: Basic_play_by_play includes score_change, cards, and substitutions. Deeper_play_by_play includes all other event types.

    Q: How are replay cup matches handled in the feeds?

    A: Within the Summary, Timeline, or Lineups feeds you can locate the round data for a given match. In that round data you can find the number of matches in the cup round (cup_round_number_of_sport_events) and the number of the given match in the cup round (cup_round_sport_event_number). The values for cup_round_sport_event_number are detailed below:

    • 1 = Replay
    • 2 = 1st Replay
    • 3 = 2nd Replay

    Q: How are group IDs delivered in the stage array with the various types?

    A: With the type of "league" they will have a sr:league prefix. With the type of "cup" they will have a sr:cup prefix.

    Q: Which regions are covered with TV Channel data?

    A: We offer Network TV data for the United States. This will be available for MLS, World Cup, EPL, UEFA Champions League, Bundesliga, Liga MX, and Gold Cup.

    Q: Why does the coverage of a cup competition not match the data in the feeds?

    A: For cup competitions, coverage levels may vary from the early rounds to latter stages. Coverage properties are set at a competition level and will display the best coverage we offer for a sport event in this competition.

    Q: How are the seasonal competitor statistics handled within the feed?

    A: Statistics from any qualification rounds will not be displayed. The feed will only display data from the main competition.

    Q: How do you define the key data points?

    A: Data points and their descriptions can be found in our Data Dictionary.

    Q: What prompts a match to appear in Sport Events Updated?

    A: Changes to score, match status, or schedule in last 24 hours would cause a match to display in this endpoint.

    Q: How will a sport event behave when it is not covered with live scores?

    A: When a sport_event is not covered live, the status and match_status will remain as not_started until results are entered post-match.

    Q: How is the minutes_played statistic calculated?

    A: Minutes played is calculated based on 90 minutes in the match. We do not include stoppage_time.

    Q: Do you cover VAR events?

    A: VAR events are supported with events 'video_assistant_referee' & 'video_assistant_referee_over' however we cannot guarantee the accuracy or frequency of these events.

    Q: How are “live” feeds handled in the API?

    A: Sport Events appear in the feed 10 minutes before the scheduled start time and are removed 10 minutes after the Sport Event is ended.

    Q: What are the possible standings types I can observe in the Standings feed?

    A: Listed below are the values for standing – type.

    • total
    • home
    • away
    • first_half_total
    • first_half_home
    • first_half_away
    • second_half_total
    • second_half_home
    • second_half_away

    Q: Why can't I find a particular match in the Daily Schedules or Sport Events Updated feeds?

    A: These endpoints support pagination and return 200 entries by default. To return more matches, an additional query string parameter must be used after your API key. For example, appending &start=200 will return the next 200 entries per page, &start=400 will return the next 200, and so on.

    Q: Do you have player transfer data available?

    A: We use roles from player profiles to create a Season Transfers endpoint. This will display any player recently assigned to a team in a season that is covered by our squad coverage and has player_transfer_history="true".

    This can include youth players that have recently been added to a matchday squad. If there is no previous club within 10 days, then this will be understood to be a free agent and therefore no from_competitor will display. For transfer_date, we use multiple sources and cannot guarantee the accuracy.

    Q: Why does the change attribute not update for Live Standings?

    A: The ‘change’ attribute is only available post-match and will display movement from the previous gameweek/round.

    Q: When will lineups confirmed show as true?

    A: Lineups information will display as they are entered. Once completed, they are then confirmed at which point the attribute for lineups confirmed will update to true. This will only show for matches that have lineups_availability="pre"

    Q: Are Live Standings available?

    A: Live standings are delivered by default in the Standings endpoint. Live standings use an automatic set of tiebreaker rules that are calculated based on the scores while matches are in progress. We recommend adding the parameter live=false to a Standings request to retrieve standings when matches are not in progress. This will consider any additional tie-break criteria that a competition may use if competitors are level.

    Q: How do I locate the TTL (Time to Live)/cache on an API endpoint?

    A: The cache (in seconds) can be accessed in the returned header information on each RESTful API call, under cache-control.
    ex. cache-control: max-age=1, public, s-maxage=1 or
    cache-control: public, must-revalidate, max-age=120

    Q: What are the possible values for cup_roundstate in the Season Links feed?

    A: Listed below are the values and definitions for cup_round - state. These can be leveraged to determine the status of a cup round.

    • empty - A matchup has been created but neither the match details nor the competitors are known.
    • unseeded_fixture - Match details are known but competitors are unknown.
    • partial_seeded - One competitor is known.
    • partial_seeded_fixture - Match details and one competitor are known.
    • seeded - Both competitors are known.
    • seeded_fixture - Match details and both competitors are known.
    • unstarted - Match(es) have been added.
    • on_going - The first match has started.
    • decided - The last match has ended.
    • winner - The winner is known.
    • cancelled – The matchup has been cancelled.

    Q: What are the possible values for match situation status (match_situation.status)?

    A: Listed below are the values and definitions for match_situation - status. These can be leveraged to determine the status of a ball in play.

    • safe - Team in possession of the ball is inside their defensive half
    • dangerous - Team in possession is in the opponent’s half but not near the penalty box
    • attack - Team in possession is in the opponent’s half, near the penalty box

    Q: Why is goals scored the only statistic available in Season Leaders and Season Competitor Statistics for some competitions?

    A: This is determined by the assists="false" property in the Season Info feed which indicates that stats below goals_scored are not guaranteed for the competition in question.

    Return to top

    Docs Navigation