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:
>
Call the Schedule endpoint and find the Race Id for your desired race
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
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.
time-tbd - The race time is yet to be determined.
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.