NASCAR v3

Frequently Asked Questions
Quick Access
Postman Collection XSD Schema
Download
## NASCAR API Overview Sportradar is the official data provider of real-time NASCAR data! We combine on-track speed and accuracy with in-depth race and seasonal driver statistics. All three NASCAR series (Cup, Xfinity, and Trucks) are covered in full. The NASCAR API is consistent in structure, format, and behavior with our other League Specific APIs. Our primary feeds return schedules, standings, team and driver data, and real-time race leaderboards. Our other feeds provide a host of complimentary statistics and information, including:
  • Entry lists
  • Practice leaderboards
  • Qualifying leaderboards
  • Seasonal driver statistics
  • Detailed track profiles
API API Version Data Entry Workflow
NASCAR v3 Data Entry Workflow
Note: Authentication is required for all API calls.
## NASCAR v3 API Map To best utilize the NASCAR 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 leaderboard for a given race: >
  1. Call the Schedule endpoint and find the Race Id for your desired race
  2. Call the Race Leaderboard using the Race Id
>The leaderboard for this race is displayed. The primary Schedule feeds require only a Series Id (e.g. 'mc' for Cup) to call the endpoint. These feeds provide season Race Ids, which can be used to generate each of the Event feeds. ## Coverage Our NASCAR API provides real-time updates for Cup, Xfinity, and Truck events. Each race, practice and qualifying event updates live, with lap-by-lap coverage. ## Daily Change Log Provides IDs and timestamps for race information, race results, driver information, track information, or standings that have been modified on a given date. To receive the data updates, use these unique IDs to pull relevant API feeds.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Series & Event Info: Season ID
Season Year
Series Alias
Series ID
Series Name
Race Info: Race ID Race Name
Track Info: Track ID Track Name
Car Info: Car ID
Car Number
Manufacturer ID Manufacturer Name
Driver Info: Driver Full Name Driver ID
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/2022/06/12/changes.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", "/nascar-ot3/2022/06/12/changes.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/nascar-ot3/2022/06/12/changes.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Daily Change Log feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{year}`/`{month}`/`{day}`/changes.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | 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. | To retrieve the XML Schema Definition (.XSD) for the Daily Change Log, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/changelog-v2.0.xsd?api_key=`{your_api_key}` Return to top ## Driver Standings Provides detailed driver standings and season statistics, including starting position, finishing position, and laps completed averages.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Series & Event Info: Season ID
Season Year
Series Alias
Series ID
Series Name
Driver Info: Driver First Name
Driver Full Name
Driver ID
Driver In Chase Flag
Driver Last Name
Driver Status
Driver Standings Info: Average Finish Position
Average Laps Completed
Average Start Position
Chase Bonus
Chase Stage Wins
Chase Wins
Did Not Finish
Laps Led
Laps Led Percentage
Money Earned
Points
Points Behind Leader
Poles
Rank
Stage Wins
Starts
Top 10 Finishes
Top 15 Finishes
Top 20 Finishes
Top 5 Finishes
Total Laps Completed
Wins
Rookie Standings Info: Average Finish Position
Average Laps Completed
Average Start Position
Chase Bonus
Chase Stage Wins
Chase Wins
Did Not Finish
Laps Led
Laps Led Percentage
Money Earned
Points
Points Behind Leader
Poles
Rank
Stage Wins
Starts
Top 10 Finishes
Top 15 Finishes
Top 20 Finishes
Top 5 Finishes
Total Laps Completed
Wins
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/2022/standings/drivers.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", "/nascar-ot3/mc/2022/standings/drivers.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/nascar-ot3/mc/2022/standings/drivers.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Driver Standings feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/`{year}`/standings/drivers.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | year | Year in 4 digit format (YYYY). | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Driver Standings, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/standings-v2.0.xsd?api_key=`{your_api_key}` Return to top ## Driver Statistics Provides seasonal statistics for all drivers, catalogued by track type, track name, and race name.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Series & Event Info: Season ID
Season Year
Series Alias
Series ID
Series Name
Race Info: Race Name
Track Info: Track ID Track Name Track Type
Driver Info: Birth Place
Children
College
Country
Date of Birth
First Name
Full Name
Gender
Height
Hobbies
ID
Last Name
Residence
Rookie Year
Status
Twitter Handle
Weight
Season Statistics Info: Average Finish Position
Average Start Position
Did Not Finish
Laps Completed
Laps Led
Lead Lap Finishes
Miles Completed
Money Earned
Poles
Running at Finish
Top 10 Finishes
Top 5 Finishes
Total Races
Wins
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/drivers/2022/drivers.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", "/nascar-ot3/mc/drivers/2022/drivers.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/nascar-ot3/mc/drivers/2022/drivers.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Driver Statistics feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/drivers/`{year}`/drivers.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | year | Year in 4 digit format (YYYY). | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Driver Statistics, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/statistics-v3.0.xsd?api_key=`{your_api_key}` Return to top ## Drivers Provides detailed driver biographical information for a given season, including information regarding their cars and teams.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Series & Event Info: Season ID
Season Year
Series Alias
Series ID
Series Name
Car Info: Car ID
Car Number
Crew Chief
Engine ID
Engine Name
Manufacturer ID
Manufacturer Name
Owner ID
Owner Name
Sponsors
Status
Driver Info: Birth Place
Children
College
Country
Date of Birth
First Name
Full Name
Gender
Height
Hobbies
ID
Last Name
Points Eligible
Residence
Rookie Year
Status
Twitter Handle
Weight
Team Info: Owner ID
Owner Name
Team ID Team Name
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/2022/drivers/list.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", "/nascar-ot3/mc/2022/drivers/list.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/nascar-ot3/mc/2022/drivers/list.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Drivers feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/`{year}`/drivers/list.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | year | Year in 4 digit format (YYYY). | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Drivers list, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/series-v2.0.xsd?api_key=`{your_api_key}` Return to top ## Entry List Provides information regarding all drivers scheduled to attempt to qualify for a race.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Race Info: Award Pole
Chase Race
Condition
Distance
ID
Laps
Name
Number
Purse
Scheduled Start Date/Time
Status
Track Info: Back Stretch
Banking
Distance
Front Stretch
ID
Name
Seating
Shape
Car Info: Car ID
Car Number
Crew Chief
Manufacturer ID
Manufacturer Name
Owner ID
Owner Name
Sponsors
Driver Info: First Name
Full Name
ID
Last Name
Points Eligible
Team Info: Owner ID
Owner Name
Team ID Team Name
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/entry_list.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", "/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/entry_list.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/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/entry_list.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Entry List feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/races/`{race_id}`/entry_list.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | race_id | ID for the given race. | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Entry List, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/race-v3.0.xsd?api_key=`{your_api_key}` Return to top ## Manufacturer Standings Provides standings information for manufacturers for a given series.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Series & Event Info: Season ID
Season Year
Series Alias
Series ID
Series Name
Car Info: Manufacturer ID Manufacturer Name
Manufacturer Standings Info: Points
Points Behind Leader
Rank Wins
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/2022/standings/manufacturers.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", "/nascar-ot3/mc/2022/standings/manufacturers.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/nascar-ot3/mc/2022/standings/manufacturers.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Manufacturer Standings feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/`{year}`/standings/manufacturers.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | year | Year in 4 digit format (YYYY). | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Manufacturer Standings, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/standings-v2.0.xsd?api_key=`{your_api_key}` Return to top ## Owner Standings Provides standings information for car owners for a given series.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Series & Event Info: Season ID
Season Year
Series Alias
Series ID
Series Name
Car Info: Car Number
In Chase Flag
Owner ID
Owner Name
Sponsors
Status
Owner Standings Info: Chase Bonus
Did Not Finish
Points
Points Behind Leader
Rank
Stage Wins
Starts
Top 10 Finishes
Top 15 Finishes
Top 20 Finishes
Top 5 Finishes
Wins
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/2022/standings/owners.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", "/nascar-ot3/mc/2022/standings/owners.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/nascar-ot3/mc/2022/standings/owners.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Owner Standings feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/`{year}`/standings/owners.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | year | Year in 4 digit format (YYYY). | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Owner Standings, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/standings-v2.0.xsd?api_key=`{your_api_key}` Return to top ## Playoff Schedule Provides detailed schedule info for all playoff events associated with a given series.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Series & Event Info: Event ID
Event Name
Event Start Date
Playoff Round Driver Limit
Playoff Round ID
Playoff Round Name
Playoff Round Status
Season ID
Season Year
Series Alias
Series ID
Series Name
Race Info: Actual End Time
Actual Start Time
Award Pole
Broadcast - Cable
Broadcast - Internet
Broadcast - Network
Broadcast - Radio
Broadcast - Satellite
Chase Race
Distance
ID
Laps
Name
Number
Scheduled Start Date/Time
Status
Track Info: Address
Back Stretch
Banking
City
Completion Year
Country
Distance
Front Stretch
ID
Market
Name
Owner
Seating
Shape
State
Surface
Type
Zip Code
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/2021/playoff/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", "/nascar-ot3/mc/2021/playoff/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/nascar-ot3/mc/2021/playoff/schedule.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Playoff Schedule feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/`{year}`/playoff/schedule.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | year | Year in 4 digit format (YYYY). | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Playoff Schedule, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/schedule-v2.0.xsd?api_key=`{your_api_key}` Return to top ## Practice Leaderboard Provides practice information for all drivers entered in the field including sequence, speed, time, and finish position.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Race Info: Award Pole
Chase Race
Condition
Distance
ID
Laps
Name
Number
Purse
Scheduled Start Date/Time
Status
Track Info: Back Stretch
Banking
Distance
Front Stretch
ID
Name
Seating
Shape
Car Info: Car ID
Car Number
Crew Chief
Manufacturer ID
Manufacturer Name
Owner ID
Owner Name
Sponsors
Driver Info: First Name
Full Name
ID
Last Name
Points Eligible
Team Info: Owner ID
Owner Name
Team ID Team Name
Practice Statistics Info: Broadcast - Cable
Broadcast - Internet
Broadcast - Network
Broadcast - Radio
Broadcast - Satellite
Laps Time
Laps Completed
Position
Practice End Time
Practice Sequence
Practice Start Time
Practice Status
Result Status
Speed
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/practices.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", "/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/practices.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/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/practices.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Practice Leaderboard feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/races/`{race_id}`/practices.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | race_id | ID for the given race. | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Practice Leaderboard, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/race-v3.0.xsd?api_key=`{your_api_key}` Return to top ## Qualifying Leaderboard Provides qualifying information for all drivers entered in the field including fastest speed, time, and finish position.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Race Info: Award Pole
Chase Race
Condition
Distance
ID
Laps
Name
Number
Purse
Scheduled Start Date/Time
Status
Track Info: Back Stretch
Banking
Distance
Front Stretch
ID
Name
Seating
Shape
Car Info: Car ID
Car Number
Crew Chief
Manufacturer ID
Manufacturer Name
Owner ID
Owner Name
Sponsors
Driver Info: First Name
Full Name
ID
Last Name
Points Eligible
Team Info: Owner ID
Owner Name
Team ID Team Name
Qualifying Statistics Info: Best Lap Time
Best Position
Best Speed
Broadcast - Cable
Broadcast - Internet
Broadcast - Network
Broadcast - Radio
Broadcast - Satellite
Entry Status
Qualifying End Time
Qualifying Start Time
Qualifying Status
Round - Lap Time
Round - Laps Completed
Round - Position
Round - Round Number
Round - Speed
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/qualifying.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", "/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/qualifying.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/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/qualifying.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Qualifying Leaderboard feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/races/`{race_id}`/qualifying.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | race_id | ID for the given race. | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Qualifying Leaderboard, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/race-v3.0.xsd?api_key=`{your_api_key}` Return to top ## Race Leaderboard Provides detailed information concerning a drivers race performance during and after the race.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Race Info: Actual Distance
Actual End Time
Actual Start Time
Average Speed
Award Pole
Chase Race
Comments
Condition
Distance
Elapsed Time
Flag State - Beneficiary
Flag State - Comments
Flag State - Lap
Flag State - Sequence
Flag State - Stage
Id
Laps
Laps Completed
Lead Changes
Margin of Victory
Name
Number
Number of Caution Laps
Number of Cautions
Purse
Scheduled Start Date/Time
Stage 1 Laps
Stage 2 Laps
Stage 3 Laps
Stage Count
Status
Track Info: Back Stretch
Banking
Distance
Front Stretch
ID
Name
Seating
Shape
Car Info: Car ID
Car Number
Crew Chief
Manufacturer ID
Manufacturer Name
Owner ID
Owner Name
Sponsors
Driver Info: First Name
Full Name
ID
Last Name
Points Eligible
Team Info: Owner ID
Owner Name
Team ID Team Name
Race Statistics Info: Average Position
Average Restart Speed
Average Speed
Behind Leader
Best Lap
Best Lap Speed
Best Lap Time
Bonus Points
Driver Rating
Elapsed Time
Fastest Laps
Laps Behind
Laps Completed
Laps Led
Laps Led - Sequence
Laps Led - Start Lap
Last Lap Speed
Last Lap Time
Money Earned
Penalty Points
Pit Stops
Pit Stops - In Time
Pit Stops - Lap
Pit Stops - Leader Lap
Pit Stops - Out Time
Pit Stops - Positions Gained
Pit Stops - Sequence
Points
Position
Result Status
Stage 1 Points
Stage 1 Wins
Stage 2 Points
Stage 2 Wins
Stage 3 Points
Stage 3 Wins
Starting Position
Times Led
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/results.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", "/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/results.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/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/results.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Race Leaderboard feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/races/`{race_id}`/results.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | race_id | ID for the given race. | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Race Leaderboard, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/race-v3.0.xsd?api_key=`{your_api_key}` Return to top ## Rookie Standings Provides detailed rookie driver standings and season statistics, including starting position, finishing position, and laps completed averages.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Series & Event Info: Season ID
Season Year
Series Alias
Series ID
Series Name
Driver Info: Driver First Name
Driver Full Name
Driver ID
Driver In Chase Flag
Driver Last Name
Driver Status
Driver Standings Info: Average Finish Position
Average Laps Completed
Average Start Position
Chase Bonus
Chase Stage Wins
Chase Wins
Did Not Finish
Laps Led
Laps Led Percentage
Money Earned
Points
Points Behind Leader
Poles
Rank
Stage Wins
Starts
Top 10 Finishes
Top 15 Finishes
Top 20 Finishes
Top 5 Finishes
Total Laps Completed
Wins
Rookie Standings Info: Average Finish Position
Average Laps Completed
Average Start Position
Chase Bonus
Chase Stage Wins
Chase Wins
Did Not Finish
Laps Led
Laps Led Percentage
Money Earned
Points
Points Behind Leader
Poles
Rank
Stage Wins
Starts
Top 10 Finishes
Top 15 Finishes
Top 20 Finishes
Top 5 Finishes
Total Laps Completed
Wins
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/2022/standings/rookies.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", "/nascar-ot3/mc/2022/standings/rookies.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/nascar-ot3/mc/2022/standings/rookies.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Rookie Standings feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/`{year}`/standings/rookies.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | year | Year in 4 digit format (YYYY). | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Rookie Standings, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/standings-v2.0.xsd?api_key=`{your_api_key}` Return to top ## Schedule Provides detailed schedule info for all events in a given series.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Series & Event Info: Event ID
Event Name
Event Start Date
Season ID
Season Year
Series Alias
Series ID
Series Name
Race Info: Actual End Time
Actual Start Time
Award Pole
Broadcast - Cable
Broadcast - Internet
Broadcast - Network
Broadcast - Radio
Broadcast - Satellite
Chase Race
Distance
ID
Laps
Name
Number
Prior Winner - First Name
Prior Winner - Full Name
Prior Winner - ID
Prior Winner - Last Name
Scheduled Start Date/Time
Stage 1 Laps
Stage 2 Laps
Stage 3 Laps
Stage Count
Status
Track Info: Address
Back Stretch
Banking
City
Completion Year
Country
Distance
Front Stretch
ID
Market
Name
Owner
Seating
Shape
State
Surface
Type
Zip Code
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/2022/races/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", "/nascar-ot3/mc/2022/races/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/nascar-ot3/mc/2022/races/schedule.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Schedule feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/`{year}`/races/schedule.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | year | Year in 4 digit format (YYYY). | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Schedule, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/schedule-v2.0.xsd?api_key=`{your_api_key}` Return to top ## Starting Grid Provides the official start order of a race.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Race Info: Award Pole
Chase Race
Condition
Distance
ID
Laps
Name
Number
Purse
Scheduled Start Date/Time
Status
Track Info: Back Stretch
Banking
Distance
Front Stretch
ID
Name
Seating
Shape
Car Info: Car ID
Car Number
Crew Chief
Manufacturer ID
Manufacturer Name
Owner ID
Owner Name
Sponsors
Driver Info: First Name
Full Name
ID
Last Name
Points Eligible
Team Info: Owner ID
Owner Name
Team ID Team Name
Qualifying Statistics Info: Best Lap Time
Best Position
Best Speed Entry Status
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/starting_grid.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", "/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/starting_grid.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/nascar-ot3/mc/races/881e7fdc-6735-40ae-a880-35314669c722/starting_grid.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Starting Grid feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/`{nascar_series}`/races/`{race_id}`/starting_grid.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | nascar_series | Cup (sc or mc), Xfinity (xf), or Trucks (cw or go). | | race_id | ID for the given race. | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Starting Grid, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/race-v3.0.xsd?api_key=`{your_api_key}` Return to top ## Tracks Provides detailed information regarding all tracks within the Cup, Xfinity, and Craftsman race series.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Track Info: Address
Back Stretch
Banking
City
Completion Year
Country
Distance
Front Stretch
ID
Market
Name
Owner
Seating
Shape
State
Surface
Type
Zip Code
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-ot3/tracks/list.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", "/nascar-ot3/tracks/list.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/nascar-ot3/tracks/list.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Tracks feed by replacing the parameters in the following URL: https://api.sportradar.us/nascar-`{access_level}{version}`/tracks/list.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | access_level | Defines the access level of your API key as Production (o) or Trial (ot). | | version | Version number of the API you are accessing (Current Version: 3). | | format | xml or json. | | your_api_key | Your API key. | To retrieve the XML Schema Definition (.XSD) for the Tracks list, replace the parameters in the following URL. https://api.sportradar.us/nascar-`{access_level}{version}`/schema/track-v2.0.xsd?api_key=`{your_api_key}` Return to top ## Frequently Asked Questions

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: What are the "race - status" values I can expect to see in the feeds and their definitions?

A: Here are the race statuses and their descriptions:

  • scheduled – The race is scheduled to occur.
  • initialized – We are ready to begin recording actions against the scheduled race.
  • practice – We are currently in the practice round.
  • qualifying – We are currently in the qualifying round.
  • prerace – Prerace may occur before practice, qualifying, or warmup rounds.
  • inprogress – The race is in progress.
  • complete – The race is over, but stat validation is not complete.
  • closed – The race is over and the statistics have been validated.
  • delayed – The race has been delayed.
  • canceled – The race has been canceled. No makeup race will be played as a result.
  • rescheduled – The race has been postponed and will be rescheduled at a later date.
  • maintenance – The closed race has been reopened to correct one or more statistics. We would recommend against pulling data for a race while in this status.
  • warmup – The scheduled race is set to take place and will begin soon.

Q: What are the "practice - status" values I can expect to see in the feeds and their definitions?

A: Here are the practice statuses and their descriptions:

  • scheduled – The race is scheduled to occur.
  • inprogress – The race is in progress.
  • delayed – The race has been delayed.
  • postponed - The race has been postponed.
  • canceled – The race has been canceled.
  • complete – The race is over, we are in the process of validating the race statistics.
  • time-tbd - The race time is yet to be determined.

Q: What are the "qualifying - status" values I can expect to see in the feeds and their definitions?

A: Here are the qualifying statuses and their descriptions:

  • no-qualifying - There is no qualifying race.
  • scheduled – The race is scheduled to occur.
  • inprogress – The race is in progress.
  • delayed – The race has been delayed.
  • postponed - The race has been postponed.
  • canceled – The race has been canceled.
  • complete – The race is over, we are in the process of validating the race statistics.
  • time-tbd - The race time is yet to be determined.

Q: What are the "driver - status" values I can expect to see in the feeds and their definitions?

A: Here are the driver statuses and their descriptions:

  • ACT - Active
  • RET – Retired

Q: What are the race conditions I can expect to see in the feeds and their definitions?

A: Here are the race conditions and their descriptions:

  • normal – The race is under normal racing conditions.
  • accident_caution – The race is under caution due to an accident.
  • conditions_caution – The race is under caution due to track conditions.
  • weather_caution – The race is under caution due to weather conditions.
  • accident_suspended – The race has been suspended due to an accident.
  • conditions_suspended – The race has been suspended due to track conditions.
  • weather_suspended – The race has been suspended due to weather conditions
  • accident_shortened – The race has been shortened due to an accident.
  • conditions_shortened – The race has been shortened due to track conditions.
  • weather_shortened –The race has been shortened due to weather conditions.
  • pitstops – The race is in progress, but all cars are in the pits.

Q: What are the possible driver statuses for the "practice - status", "qualifying - status", and race "result - status" that I can expect and what are their definitions?

A: We have 2 different sets of driver statuses: statuses that are used during the session and statuses used post session.

Here are the live race driver statuses and their descriptions:

  • ontrack – The driver is currently active in the session.
  • garage – The driver is currently in the garage.
  • accident – The driver is currently off the track, or ended his/her session due to an accident.
  • off – The driver has gone off track.

Here are the post race driver statuses and their descriptions:

  • garage – The driver ended the session in the garage for an unknown reason.
  • running – The driver ended the session running.
  • engine – The driver ended the session due to engine issues.
  • vibration – The driver ended the session due to vibration issues.
  • brakes – The driver ended the session due to a brake issue.
  • fuelpump – The driver ended the session due to issue with the fuel pump.
  • spindle – The driver ended the session due to an issues with the spindle.
  • transmission – The driver ended the session due to a transmission issue.
  • handling – The driver ended the session due to handling issues.
  • ignition – The driver ended the session due to an ignition issue.
  • oilleak – The driver ended the session due to an oil leak.
  • overheating – The driver ended the session due to an overheating issue.
  • electrical – The driver ended the session due to an electrical issue.
  • axle – The driver ended the session due to an issue with an axle.
  • clutch – The driver ended the session due to an issue with the clutch.
  • suspension - The driver ended the session due to suspension issues.
  • reargear – The driver ended the session due to rear gear issues.
  • dnq – The driver did not qualify for the race.
  • withdrew – The driver has withdrawn.
  • disqualified – The driver has been disqualified.
  • dvp - The driver ended the session due to the Damaged Vehicle Policy.
  • alternator - The driver ended the session due to an issue with an alternator.
  • tooslow - The driver ended the session due to not making minimal speed.

Q: What are the flag states I can expect to see in the feeds and their definitions?

A: Here are the flag states:

  • warmup
  • green
  • yellow
  • red
  • finish

Q: How does Sportradar handle Heat Races like the Exhibition Cup race in February and Dirt Track Races?

A: Heat Races behave like the Duel Races at Daytona. Each Heat Race has its own Race ID under the appropriate Event ID. These will be short distance races that last under 15 minutes. If a heat race cancels due to weather, the status of the race will move to canceled. Once a heat race is over, the starting grid for the main race updates.

Q: Why is the Qualifying Leaderboard empty for the Cup All-Star Race?

A: For the Cup All-Star Race in Charlotte, the qualifying feed will be empty, as qualifying is handled differently at that track. The starting grid will not be finalized until 15 minutes prior to the scheduled race start and will be available in the Starting Grid feed.

Return to top

Docs Navigation