Winter Sports v1

Frequently Asked Questions
Quick Access
Postman Collection XSD Schema
Download
API API Version
Winter Sports v1
Note: Authentication is required for all API calls.
## Winter Sports v1 API Map To best utilize the Winter Sports API, you will need several parameters to create your API calls. The map below illustrates how you can obtain the parameters you need. >

Example:

>To find the summary for a given event: >
  1. Call the Seasons endpoint and find the Stage Id for the current season
  2. Call the Sport Event Summary (Schedule) using the 'season' Stage Id
  3. Locate the Stage Id for the upcoming event
  4. Call the Sport Event Summary (Event) using the 'event' Stage Id
>The summary info for this race is displayed. The primary Seasons feed requires only a human-readable parameter to call the endpoint. This feed provides season Stage Ids, which can be used to generate descending Sport Event Summary feeds to include more detailed event info. These feeds can then be used to generate profile feeds. ## Competitor Merge Mappings Provides the valid Sportradar Id in cases when two competitors have been merged into one. Mapping entries will remain in the feed for 7 days.
TTL / Cache: 300 seconds
Update Frequency: As Necessary
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/wintersports/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", "/wintersports/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/wintersports/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/wintersports/`{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

English (en) is the only fully supported language for this API. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Competitor Profiles
TTL / Cache: 300 seconds
Update Frequency: As Necessary
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/wintersports/trial/v1/en/competitors/sr:competitor:13990/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.us") conn.request("GET", "/wintersports/trial/v1/en/competitors/sr:competitor:13990/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.us/wintersports/trial/v1/en/competitors/sr:competitor:13990/profile.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. > Try it out now in our API Sandbox. > Note: Authentication is required for all API calls. This endpoint retrieves the Competitor Profiles. https://api.sportradar.us/wintersports/`{access_level}`/`{version}`/`{language_code}`/competitors/`{competitor_id}`/profile.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production), Testing (testing), or Trial (trial). | | `version` | Version number of the API you are accessing (Current Version: v1). | | `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `competitor_id` | Id of a given competitor. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to API map ## Season Schedule
TTL / Cache: 300 seconds
Update Frequency: As Necessary
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/wintersports/trial/v1/en/sport_events/sr:stage:421758/schedule.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.us") conn.request("GET", "/wintersports/trial/v1/en/sport_events/sr:stage:421758/schedule.xml?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -X GET "https://api.sportradar.us/wintersports/trial/v1/en/sport_events/sr:stage:421758/schedule.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. > Try it out now in our API Sandbox. > Note: Authentication is required for all API calls. This endpoint retrieves the Season Schedule. https://api.sportradar.us/wintersports/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{stage_id}`/schedule.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production), Testing (testing), or Trial (trial). | | `version` | Version number of the API you are accessing (Current Version: v1). | | `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `stage_id` | Stage id of a given season. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to API map ## Seasons
TTL / Cache: 300 seconds
Update Frequency: As Necessary
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/wintersports/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.us") conn.request("GET", "/wintersports/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.us/wintersports/trial/v1/en/seasons.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. > Try it out now in our API Sandbox. > Note: Authentication is required for all API calls. This endpoint retrieves the list of available seasons. https://api.sportradar.us/wintersports/`{access_level}`/`{version}`/seasons.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production), Testing (testing), or Trial (trial). | | `version` | Version number of the API you are accessing (Current Version: v1). | | `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to API map ## Sport Event Summary (Discipline)
TTL / Cache: 300 seconds
Update Frequency: As Necessary
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/wintersports/trial/v1/en/sport_events/sr:stage:364303/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.us") conn.request("GET", "/wintersports/trial/v1/en/sport_events/sr:stage:364303/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.us/wintersports/trial/v1/en/sport_events/sr:stage:364303/summary.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. > Try it out now in our API Sandbox. > Note: Authentication is required for all API calls. This endpoint retrieves the summary of a discipline. https://api.sportradar.us/wintersports/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{stage_id}`/summary.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production), Testing (testing), or Trial (trial). | | `version` | Version number of the API you are accessing (Current Version: v1). | | `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `stage_id` | Stage id of a given discipline. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to API map ## Sport Event Summary (Event)
TTL / Cache: 300 seconds
Update Frequency: As Necessary
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/wintersports/trial/v1/en/sport_events/sr:stage:419260/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.us") conn.request("GET", "/wintersports/trial/v1/en/sport_events/sr:stage:419260/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.us/wintersports/trial/v1/en/sport_events/sr:stage:419260/summary.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. > Try it out now in our API Sandbox. > Note: Authentication is required for all API calls. This endpoint retrieves the summary of an event. https://api.sportradar.us/wintersports/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{stage_id}`/summary.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production), Testing (testing), or Trial (trial). | | `version` | Version number of the API you are accessing (Current Version: v1). | | `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `stage_id` | Stage id of a given event. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to API map ## Sport Event Summary (Run)
TTL / Cache: 300 seconds
Update Frequency: As Necessary
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/wintersports/trial/v1/en/sport_events/sr:stage:421766/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.us") conn.request("GET", "/wintersports/trial/v1/en/sport_events/sr:stage:421766/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.us/wintersports/trial/v1/en/sport_events/sr:stage:421766/summary.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. > Try it out now in our API Sandbox. > Note: Authentication is required for all API calls. This endpoint retrieves the summary of a run. https://api.sportradar.us/wintersports/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{stage_id}`/summary.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production), Testing (testing), or Trial (trial). | | `version` | Version number of the API you are accessing (Current Version: v1). | | `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `stage_id` | Stage id of a given run. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to API map ## Sport Event Summary (Season)
TTL / Cache: 300 seconds
Update Frequency: As Necessary
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/wintersports/trial/v1/en/sport_events/sr:stage:364299/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.us") conn.request("GET", "/wintersports/trial/v1/en/sport_events/sr:stage:364299/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.us/wintersports/trial/v1/en/sport_events/sr:stage:364299/summary.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. > Try it out now in our API Sandbox. > Note: Authentication is required for all API calls. This endpoint retrieves the summary of a season. https://api.sportradar.us/wintersports/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{stage_id}`/summary.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production), Testing (testing), or Trial (trial). | | `version` | Version number of the API you are accessing (Current Version: v1). | | `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `stage_id` | Stage id of a given season. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to API map ## Team Profiles
TTL / Cache: 300 seconds
Update Frequency: As Necessary
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/wintersports/trial/v1/en/teams/sr:competitor:49183/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.us") conn.request("GET", "/wintersports/trial/v1/en/teams/sr:competitor:49183/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.us/wintersports/trial/v1/en/teams/sr:competitor:49183/profile.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. > Try it out now in our API Sandbox. > Note: Authentication is required for all API calls. This endpoint retrieves the Team Profiles. https://api.sportradar.us/wintersports/`{access_level}`/`{version}`/`{language_code}`/teams/`{competitor_id}`/profiles.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production), Testing (testing), or Trial (trial). | | `version` | Version number of the API you are accessing (Current Version: v1). | | `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `competitor_id` | Competitor Id of a given team. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to API map ## Frequently Asked Questions

Q: What sports and competitions do you cover for Winter Sports v1?

A: A list of the competitions covered in this API can be found below. Note that this list is subject to change at any time. For the most accurate list of competitions, please see the Competitions endpoint in the API.

| Sport | Competitions | | ----- | ------------ | | Alpine Skiing | Alpine Skiing | | | Alpine Skiing World Championship | | | Alpine Skiing Mixed World Championship | | | Alpine Skiing Women | | | Alpine Skiing Women World Championship | | Biathlon | Biathlon | | | Biathlon World Championship | | | Biathlon Mixed | | | Biathlon Mixed World Championship | | | Biathlon Women | | | Biathlon Women World Championship | | Bobsleigh | Bobsleigh | | | Bobsleigh Women | | Cross Country Cross Country | | | Cross Country World Championship | | | Cross Country Women | | | Cross Country Women World Championship | | Figure Skating | Figure Skating | | | Figure Skating Mixed | | | Figure Skating Women | | Luge | Luge | | | Luge Women | | Nordic Combined | Nordic Combined | | | Nordic Combined World Championship | | Ski Jumping | Ski Jumping | | | Ski Jumping World Championship | | | Ski Jumping Women | | | Ski Jumping Women World Championship | | Snowboard | Snowboard | | | Snowboard World Championship | | | Snowboard Women | | | Snowboard Women World Championship | | Speed Skating | Speed Skating | | | Speed Skating Women |

Q: What seasons are found in the API?

A: 2018/19 and 2019/20 as they become available for all sports listed above.

Q: How far back does the data go?

A: Only current and the previous seasons.

Q: Are events covered live?

A: All events have results entered after all heats are completed.

Q: What statistics are in the API?

A: Only points, positions, medals, and times where applicable.

Q: When are the competitor lists available?

A: Up to a few minutes before the event is run.

Q: Do you have results for the heats/runs?

A: While some events may have limited results for heats or runs, typically there are only results for the overall event.

Q: How do I know which endpoints to hit?

A: There are only three endpoint "types": Profiles, season-based, and sport event-based. If the variable ID is stage based, you need to check the stage node to see what type it is. If type="season" that id is only designed to be placed in the season based endpoints. However, if you place a season ID in the sport_event summary endpoint it will return the results at a season level (meaning the standings). Every other stage ID including individual runs, heats, or entire events can be used on the sport_event summary to get the results.

Q: What format are date fields presented in?

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 format 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: How do I see the results of a specific run or heat in a given sport/discipline?

A: The Sport Event Summary takes any sport event ID parameter. Find the sport event ID for the event in question, and call the Sport Event Summary endpoint with that sport event ID. Within that endpoint, if the event consists of runs or heats you will find the sport event IDs for each heat. You can use that ID as a parameter in the URL of the same endpoint.

Q: What are the possible stage types that I can expect in the feeds?

A: Here is a list of possible stage types:

  • season
  • sport
  • run
  • discipline
  • event
  • eight_final
  • quarter_final
  • semi_final
  • small_final
  • final
  • qualifying
  • consolation
  • placement

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

Return to top

Docs Navigation