Rally v2

Frequently Asked Questions
Quick Access
Postman Collection XSD Schema
Download
## Rally API Overview The Rally API provides schedules and post-race results for the World Rally Championship. All data is collected via Sportradar’s expert operators. Select the Rally package in our Coverage Matrix for events and data offered. This API uses a descending, stage-based structure. By changing the stage ID, you can retrieve information on a season, event, or race. Additional feeds provide complimentary stats, including racer profiles and race win probabilities.
API API Version
Rally v2
Note: Authentication is required for all API calls.
## Rally v2 API Map To best utilize the Rally 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 win probabilities for a given race: >
  1. Call the Seasons endpoint and find the Stage Id for the current season
  2. Call the Stage Schedule using the 'season' Stage Id
  3. Locate the Stage Id for the upcoming race
  4. Call the Stage Probabilities using the 'race' Stage Id
  5. Within the results locate the win probability for each racer
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 Stage Summary feeds to include more detailed info, such as events and races. These feeds can then be used to generate the profile feed. ## 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.
Update Frequency: As Necessary
Content Type: XML or JSON
Mappings Info Data Points: Name Merged Id Retained Id
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/rally/trial/v2/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", "/rally/trial/v2/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/rally/trial/v2/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/rally/`{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: v2). | | `language_code` | Supported Locales | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Competitor Profile Provides biographical information for a given driver.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Competitor Information Data Points: Country Code
Country Code of Residence
Country of Residence
Country of Residence Id
Gender
Id
Name
Nationality
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/rally/trial/v2/en/competitors/sr:competitor:358352/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", "/rally/trial/v2/en/competitors/sr:competitor:358352/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/rally/trial/v2/en/competitors/sr:competitor:358352/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/rally/`{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: v2). | | `language_code` | 2 letter code for supported languages: en (English). | | `competitor_id` | Id of a given competitor. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Deleted Stages Provides all deleted stages within a given season.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Stage Information Data Points: Description
Disabled
Scheduled
Scheduled End
Single Event
Stage Id
Type
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/rally/trial/v2/en/seasons/sr:stage:694124/deleted_stages.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", "/rally/trial/v2/en/seasons/sr:stage:694124/deleted_stages.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/rally/trial/v2/en/seasons/sr:stage:694124/deleted_stages.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Deleted Stages feed by replacing the parameters in the following URL: https://api.sportradar.com/rally/`{access_level}`/`{version}`/`{language_code}`/seasons/`{stage_id}`/deleted_stages.`{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: v2). | | `language_code` | 2 letter code for supported languages: en (English). | | `stage_id` | Id of a given stage. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Seasons Provides a complete historical list of available seasons. This is the starting point for the Rally API.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Category & Sport Information Data Points: Category Id
Category Name
Sport Id Sport Name
Stage Information Data Points: Description
Disabled
Scheduled
Scheduled End
Status
Stage Id
Type
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/rally/trial/v2/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", "/rally/trial/v2/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/rally/trial/v2/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/rally/`{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: v2). | | `language_code` | 2 letter code for supported languages: en (English). | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Stage Probabilities Provides the outrights for each driver for a given race.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Category & Sport Information Data Points: Category Id
Category Name
Sport Id Sport Name
Competitor Information Data Points: Id Name Gender
Stage Information Data Points: Description
Disabled
Scheduled
Scheduled End
Status
Stage Id
Type
Probability Information Data Points: Market Description
Market Name
Market Type
Outcome Id
Outcome Name
Outcome Probability
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/rally/trial/v2/us/sport_events/sr:stage:694124/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", "/rally/trial/v2/us/sport_events/sr:stage:694124/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/rally/trial/v2/us/sport_events/sr:stage:694124/probabilities.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Stage Probabilities feed by replacing the parameters in the following URL: https://api.sportradar.com/rally/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{stage_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: v2). | | `language_code` | 2 letter code for supported languages: en (English). | | `stage_id` | Id of a given stage. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Stage Schedule Provides the schedule for a given stage.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Category & Sport Information Data Points: Category Id
Category Name
Sport Id Sport Name
Stage Information Data Points: Description
Disabled
Scheduled
Scheduled End
Status
Stage Id
Type
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/rally/trial/v2/en/sport_events/sr:stage:686690/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.com") conn.request("GET", "/rally/trial/v2/en/sport_events/sr:stage:686690/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.com/rally/trial/v2/en/sport_events/sr:stage:686690/schedule.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Stage Schedule feed by replacing the parameters in the following URL: https://api.sportradar.com/rally/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{stage_id}`/schedule.`{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: v2). | | `language_code` | 2 letter code for supported languages: en (English). | | `stage_id` | Id of a given stage. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Stage Summary Provides schedules and results information based on the stage provided (sport, season, event, or race).
Note: Results returned in a Summary endpoint will vary depending on the type of stage provided (sport, season, event, or race).
View our extended documentation for details or open the links in the right sidebar for samples.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Category & Sport Information Data Points: Category Id
Category Name
Sport Id Sport Name
Competitor Information Data Points: Country Code
Id
Name
Nationality
Gender
Stage Information Data Points: Description
Disabled
Scheduled
Scheduled End
Status
Stage Id
Type
Results Information Data Points: Gap/Time
Points
Position
Races
Status
Victories
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/rally/trial/v2/en/sport_events/sr:stage:694124/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", "/rally/trial/v2/en/sport_events/sr:stage:694124/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/rally/trial/v2/en/sport_events/sr:stage:694124/summary.xml?api_key={your_api_key}" ``` > Click here for a Summary sample of a Sport. > Click here for a Summary sample of a Season. > Click here for a Summary sample of an Event. > Click here for a Summary sample of a Race. Access the Stage Summary feed by replacing the parameters in the following URL: https://api.sportradar.com/rally/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{stage_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: v2). | | `language_code` | 2 letter code for supported languages: en (English). | | `stage_id` | Id of a given stage. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Frequently Asked Questions

Q: How does the stage system work?

A: The Rally API uses generic stage implementation. The core of the API is built around the concept of stages. For example, an event contains all races within that event as separate stage IDs. The IDs of each stage are usable in the URL path to request information about that particular stage.

The Rally sport and seasons within it are stages as well. The sport stage consists of season stages for each annual season. Using the ID of a chosen season as a parameter in the Stage Summary endpoint you can "drill down" into each season. For example, using the 2022 season ID as a parameter in the Stage Summary endpoint, the sub-stages will be individual race events.

The best way to 'start' the navigation with the Rally API is using the Seasons endpoint. From there one can obtain the stage ID for the season required and use that as a parameter in the Stage Summary endpoint.

Stage Type Information Included Sub-stages
Sport Information about the seasons included. Note probabilities do not return valid data on this stage. Rally seasons (eg: 2021,2022)
Season Contains the season schedule, driver standings and statistics. Events on the Rally calendar for that season.
Event Information about a single event, the competitors, and the circuit. Race
Races within the event Details of the race itself, including the competitors and overall results. None

Q: What races are covered in the Rally API?

A: For a detailed breakdown of races covered, reference our Coverage Matrix.

Q: What is the Date format?

A: We present date only values 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: What are the stage types I can expect to see in the feeds?

A: Here are the Rally stages:

  • sport
  • season
  • event
  • race

Q: How do I know what "stage" I am currently looking at?

A: Each stage has a "stage" element. The stage element has an attribute "type" which displays the stage type. The different valid stage types are listed above.

Q: How do I get the probabilities for the entire season? Or only one race?

A: You can use season, event, and race stage IDs as parameters for the probabilities endpoint. Probabilities are available for the individual driver to win the season, a single event, and race stage.

Q: How do I retrieve information about an individual driver?

A: Use the Competitor Profile endpoint with the required driver's competitor ID. The best place to get the driver's competitor ID is the Stage Summary endpoint, using the season stage ID.

Q: What are the possible statuses of a race or stage?

A: Here are the possible stage statuses and their definitions:

  • Cancelled - The stage is cancelled and will not be taking place
  • Closed - The stage is over and we have validated the results
  • Completed - The stage is over, but we have not finished data collection and validation
  • Finished - The stage is over
  • Not Started - The stage has not begun
  • Preliminary - The stage is about to begin
  • Running - The stage is currently in progress

Q: Is it updated in real-time?

A: No, post-event. Meaning results of practice are available after practice session is complete, similarly for qualification sessions and the race itself.

Return to top

Docs Navigation