Classic NASCAR v3

Frequently Asked Questions
Quick Access
Postman Collection XSD Schema
Download
API API Version Data Entry Workflow
Classic NASCAR v3 Data Entry Workflow
Note: Authentication is required for all API calls.
## Classic NASCAR v3 API Map To best utilize the Classic NASCAR API, you will need 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 feed requires only a Series Id (e.g. 'mc' for Cup) to call the endpoint. This feeds provides season Race Ids, which can be used to generate each of the Event feeds. ## Coverage Our NASCAR Classic API provides real-time updates for Cup, Xfinity, and Truck events. Each race and qualifying event updates live. Practices and driver statistics are not included in the Classic API. ## 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-t3/2022/06/11/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-t3/2022/06/11/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-t3/2022/06/11/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 (p) or Trial (t). | | 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 API map ## 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-t3/mc/2022/standings/driver.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-t3/mc/2022/standings/driver.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-t3/mc/2022/standings/driver.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 (p) or Trial (t). | | 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 API map ## 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-t3/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-t3/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-t3/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 (p) or Trial (t). | | 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 API map ## 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: Chase Race
Condition
Distance
ID
Laps
Name
Number
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-t3/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-t3/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-t3/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 (p) or Trial (t). | | 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-v2.0.xsd?api_key=`{your_api_key}` Return to API map ## 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-t3/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-t3/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-t3/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 (p) or Trial (t). | | 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 API map ## 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-t3/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-t3/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-t3/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 (p) or Trial (t). | | 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 API map ## 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: Chase Race
Condition
Distance
ID
Laps
Name
Number
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
Round - Lap Time
Round - Position
Round - Round Number
Round - Speed
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.us/nascar-t3/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-t3/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-t3/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 (p) or Trial (t). | | 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-v2.0.xsd?api_key=`{your_api_key}` Return to API map ## Race Leaderboard Provides detailed information concerning a driver’s race performance during and after the race.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Race Info: Actual End Time
Actual Start Time
Average Speed
Cautions
Chase Race
Condition
Distance
Elapsed Time
Id
Laps
Laps Completed
Lead Changes
Margin of Victory
Name
Number
Scheduled Start Date/Time
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: Bonus Points
Driver Rating
Laps Behind
Laps Completed
Laps Led
Money Earned
Penalty Points
Pit Stops
Points
Position
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-t3/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-t3/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-t3/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 (p) or Trial (t). | | 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-v2.0.xsd?api_key=`{your_api_key}` Return to API map ## 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-t3/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-t3/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-t3/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 (p) or Trial (t). | | 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 API map ## 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
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
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-t3/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-t3/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-t3/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 (p) or Trial (t). | | 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 API map ## Starting Grid Provides the official start order of a race.
Update Frequency: As Necessary
Content Type: Raw XML or JSON
Race Info: Chase Race
Condition
Distance
ID
Laps
Name
Number
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-t3/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-t3/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-t3/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 (p) or Trial (t). | | 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-v2.0.xsd?api_key=`{your_api_key}` Return to API map ## 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-t3/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-t3/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-t3/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 (p) or Trial (t). | | 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 API map ## 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 statuses I can expect to see in the feeds and what are 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 – The qualifying round is over, the main race has not begun.
  • 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 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, qualifying, and race session 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.

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

Return to top

Docs Navigation