Formula 1 v2

Frequently Asked Questions
Quick Access
Postman Collection XSD Schema
Download
## Formula 1 API Overview The Formula 1 API provides schedules and live coverage for all F1 Championship races. Select the Formula 1 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, race, or any of the practice or qualifying stages. Additional feeds provide complementary stats, including:
  • Racer profiles
  • Team profiles
  • Race and Championship win probabilities
API API Version
Formula 1 v2
Note: Authentication is required for all API calls.
## Formula 1 v2 API Map To best utilize the Formula 1 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 probability of a win for each racer 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 Stage Summary feeds to include more detailed info, such as events and races. 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
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/formula1/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", "/formula1/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/formula1/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/formula1/`{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 detailed driver information including debut date, first points, first pole, and first victory.
TTL / Cache: 300 seconds
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Competitor Information Data Points: Car Nickname
Country Code
Date of Birth
Debut
First Points Date
First Pole Date 		First Victory Date
Gender
Height
Id
Name
Nationality
Official Website 		Origin Country
Origin Country Code
Place of Birth
Salary
WCS Won
Weight
Team Information Data Points: Country Code
Gender 		Name
Nationality 		Team Id
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/formula1/trial/v2/en/competitors/sr:competitor:7135/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", "/formula1/trial/v2/en/competitors/sr:competitor:7135/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/formula1/trial/v2/en/competitors/sr:competitor:7135/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/formula1/`{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` | 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 top ## Deleted Stages Provides all deleted stages within a given season.
TTL / Cache: 300 seconds
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/formula1/trial/v2/en/seasons/sr:stage:272058/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", "/formula1/trial/v2/en/seasons/sr:stage:272058/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/formula1/trial/v2/en/seasons/sr:stage:272058/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/formula1/`{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` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `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 for F1. This is the starting point for the Formula 1 API.
TTL / Cache: 300 seconds
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
Scheduled 		Scheduled End
Status 		Stage Id
Type
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/formula1/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", "/formula1/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/formula1/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/formula1/`{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` | 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 top ## Stage Probabilities Provides the outrights for each driver for a given race.
TTL / Cache: 300 seconds
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: Competitor Id
Country Code 		Gender
Name 		Nationality
Team Information Data Points: Country Code
Gender 		Name
Nationality 		Team Id
Stage Information Data Points: Air Temperature
Description
Humidity
Laps
Laps Completed 		Pit Open
Scheduled
Scheduled End
Single Event
Stage Id 		Status
Substatus
Track Temperature
Type
Weather
Probability Information Data Points: Market Description
Market Name 		Market Type
Outcome Id 		Outcome Name
Outcome Probability
Venue Information Data Points: Capacity
City
Coordinates
Country 		Country Code
Curves Left
Curves Right
Debut 		Id
Laps
Length
Official Website
Timezone
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/formula1/trial/v2/us/sport_events/sr:stage:324773/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", "/formula1/trial/v2/us/sport_events/sr:stage:324773/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/formula1/trial/v2/us/sport_events/sr:stage:324773/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/formula1/`{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` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `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.
TTL / Cache: 300 seconds
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: Air Temperature
Description
Humidity
Laps
Laps Completed 		Pit Open
Scheduled
Scheduled End
Single Event
Stage Id 		Status
Substatus
Track Temperature
Type
Weather
Venue Information Data Points: Capacity
City
Coordinates
Country 		Country Code
Curves Left
Curves Right
Debut 		Id
Laps
Length
Official Website
Timezone
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/formula1/trial/v2/en/sport_events/sr:stage:272058/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", "/formula1/trial/v2/en/sport_events/sr:stage:272058/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/formula1/trial/v2/en/sport_events/sr:stage:272058/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/formula1/`{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` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `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, practice, qualifying, qualifying part, sprint race, race, or lap).
Note: Results returned in a Summary endpoint will vary depending on the type of stage provided (season, event, practice, qualifying, qualifying part, sprint race, race, or lap).
View our extended documentation for details or open the links in the right sidebar for samples.
TTL / Cache: 10 seconds
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: Competitor Id
Country Code 		Gender
Name 		Nationality
Team Information Data Points: Country Code
Gender 		Name
Nationality 		Team Id
Stage Information Data Points: Air Temperature
Description
Humidity
Laps
Laps Completed 		Pit Open
Scheduled
Scheduled End
Single Event
Stage Id 		Status
Substatus
Track Temperature
Type
Weather
Results Information Data Points: Car Number
Fastest Lap Time
Fastest Laps
Gap/Time
Grid
Laps 		Pitstop Count
Podiums
Points
Pole Positions
Position
Races 		Races with Points
Status
Substatus
Victories
Victory Pole and Fastest Lap
Venue Information Data Points: Capacity
City
Coordinates
Country 		Country Code
Curves Left
Curves Right
Debut 		Id
Laps
Length
Official Website
Timezone
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/formula1/trial/v2/en/sport_events/sr:stage:272058/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", "/formula1/trial/v2/en/sport_events/sr:stage:272058/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/formula1/trial/v2/en/sport_events/sr:stage:272058/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 Practice. > Click here for a Summary sample of a Qualifying stage. > Click here for a Summary sample of a Qualifying part. > Click here for a Summary sample of a Sprint Race. > Click here for a Summary sample of a Race. > Click here for a Summary sample of a Lap. Access the Stage Summary feed by replacing the parameters in the following URL: https://api.sportradar.com/formula1/`{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` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `stage_id` | Id of a given stage. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Team Profile Provides detailed team information including car details, engine type, debut date, first points, first pole, first victory, and relevant staff information.
TTL / Cache: 300 seconds
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Competitor Information Data Points: Competitor Id
Country Code 		Gender
Name 		Nationality
Team Information Data Points: Back Wing Color
Car Chassis
Car Construction Year
Car Engine Name
Car Engine Size
Car Fuel Type
Car Nickname
Car Tyres
Chief Engineer
Country of Residence
Country of Residence ID 		Country Code of Residence
Debut
F1 License
First Points
First Pole
First Victory
Foundation Year
Front Color
Front Wing Color
Gender
Location 		Middle Back Center Color
Middle Back Sides Color
Middle Sides Color
Nationality
Official Website
Origin Country
Origin Country Code
President
Sport Director
Team Id
Technical Director
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/formula1/trial/v2/en/teams/sr:competitor:4514/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", "/formula1/trial/v2/en/teams/sr:competitor:4514/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/formula1/trial/v2/en/teams/sr:competitor:4514/profile.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Team Profile feed by replacing the parameters in the following URL: https://api.sportradar.com/formula1/`{access_level}`/`{version}`/`{language_code}`/teams/`{team_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` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). | | `team_id` | Id of a given team. | | `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 F1 API uses generic stage implementation. The core of the API is built around the concept of stages. For example, an event contains the following stage types: practice, qualifying, and race. Each of those stages, in turn, have stages (except Practice which has no sub-stages). The IDs of each stage are usable in the URL path to request information about that particular stage. Qualifying stages contain sub-stages known as "Qualifying Parts". In the Race stages, the sub-stages are laps. You can use the lap stage ID in the URL to get specific lap details, including driver times, and position.

The F1 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. From the race event, you can drill down into the practice, qualifying, race, and lap stages of a race using the same endpoint with different stage IDs.

The best way to "start" the navigation with the F1 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. Which is limited to the current and previous season only. Note probabilities do not return valid data on this stage. Formula 1 seasons
Season Contains the season schedule, driver and team standings and statistics. Events on the F1 calendar for that season (eg: Melbourne Grand Prix, Abu Dhabi Grand Prix, etc.).
Event Information about a single event, the competitors, the teams, and the circuit. Sessions (eg: Practice, Qualifying, Race)
Practice Competitors and results of practice such as fastest time etc. None
Qualifying Information pertaining to the qualifying stage of the event including conditions, competitors, and overall qualifying results. Qualifying Parts
Qualifying Part Information about the individual qualifying parts of the overall qualifying stage such as conditions, competitors, and results. None
Sprint Race Details of a sprint race including the competitors, laps, and results. Laps
Race Details of the race itself including the competitors, lap by lap, and overall results. Laps
Lap Specific details on individual laps such as driver positions, times, etc. Note probabilities do not return valid data on this stage. None

Q: What are the stage types I can expect to see in the feeds?

A: Here are the Formula 1 stage:

  • sport
  • season
  • event
  • practice
  • qualifying
  • qualifying_part
  • sprint_race
  • race
  • lap

Q: How do I see the Championship points table?

A: Use the stage summary endpoint and a season stage ID as the parameter. The competitors node lists competitors, ranked with points, position, victories, races, races with points, and podiums.

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' displays stage type. The different valid stage types are listed above.

Q: How do I get the probabilities for the entire Championship? 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. Probabilities are not available on the Sport, Practice, Qualifying, or Lap stages.

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 races are covered in the F1 API?

A: The entire F1 Championship. For a more detailed breakdown, reference our Coverage Matrix.

Q: Is it updated in real-time?

A: No, the F1 API provides lap by lap updates.

Q: Does this API include Qualifying and Practice sessions?

A: Yes, qualifying stages are all covered lap by lap. Practice sessions are updated post-session.

Q: Which plan should I choose ("Premium" or "Basic")?

A: Races are only covered from a lap by lap perspective. Premium provides enough calls to allow you to call the race endpoint every 10s for fresh data. The Basic plan only provides a small number of calls per session to allow for retrieving only the results.

Q: What are the possible stage and driver statuses?

A: Here are the possible stage and driver statuses:

Stage Status • Completed • Closed • Running • Cancelled • Finished • Not Started • Red flag • Yellow flag • Red and yellow flag • White flag • Safety car • Warmup • In grid Stage Sub Status • 2 hour rule • 75% rule • All laps completed • Entire track Driver Status • Pit stop • Finished • Disqualified • Did not start • Out • In race Driver Sub Status • Unknown • Retired

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 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

version 44 as of 7 months ago by Paul Sutton

Docs Navigation