IndyCar v2
Frequently Asked Questions
## IndyCar API Overview
The IndyCar API provides schedules and post-race results for the entire IndyCar Series. All data is collected via Sportradar’s expert operators.
Select the IndyCar package in our Coverage Matrix for events and data offered.
This API uses a descending, stage-based structure. By changing the stage ID, you can retrieve information on a season, event, race, or any of the practice or qualifying stages.
Additional feeds provide complementary stats, including racer profiles and race win probabilities.
## IndyCar v2 API Map
To best utilize the IndyCar API, you will need several parameters to create your API calls. The map below illustrates how you can obtain the parameters you need.
>
## Competitor Merge Mappings
Provides the valid Sportradar Id in cases when two competitors have been merged into one. Mapping entries will remain in the feed for 7 days.
```ruby
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://api.sportradar.com/indycar/trial/v2/en/competitors/merge_mappings.xml?api_key={your_api_key}")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_body
```
```python
import http.client
conn = http.client.HTTPSConnection("api.sportradar.com")
conn.request("GET", "/indycar/trial/v2/en/competitors/merge_mappings.xml?api_key={your_api_key}")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```shell
curl -X GET "https://api.sportradar.com/indycar/trial/v2/en/competitors/merge_mappings.xml?api_key={your_api_key}"
```
> The above command returns xml structured like this.
Access the Competitor Merge Mappings feed by replacing the parameters in the following URL:
https://api.sportradar.com/indycar/`{access_level}`/`{version}`/`{language_code}`/competitors/merge_mappings.`{format}`?api_key=`{your_api_key}`
| Parameter | Description |
| --------- | ----------- |
| `access_level` | Defines the access level of your API key as Production (production) or Trial (trial). |
| `version` | Version number of the API you are accessing (Current Version: v2). |
| `language_code` | Supported Locales |
| `format` | xml or json. |
| `your_api_key` | Your API key. |
Return to top
## Competitor Profile
Provides biographical information for a given driver.
```ruby
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://api.sportradar.com/indycar/trial/v2/en/competitors/sr:competitor:8101/profile.xml?api_key={your_api_key}")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_body
```
```python
import http.client
conn = http.client.HTTPSConnection("api.sportradar.com")
conn.request("GET", "/indycar/trial/v2/en/competitors/sr:competitor:8101/profile.xml?api_key={your_api_key}")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```shell
curl -X GET "https://api.sportradar.com/indycar/trial/v2/en/competitors/sr:competitor:8101/profile.xml?api_key={your_api_key}"
```
> The above command returns xml structured like this.
Access the Competitor Profile feed by replacing the parameters in the following URL:
https://api.sportradar.com/indycar/`{access_level}`/`{version}`/`{language_code}`/competitors/`{competitor_id}`/profile.`{format}`?api_key=`{your_api_key}`
| Parameter | Description |
| --------- | ----------- |
| `access_level` | Defines the access level of your API key as Production (production) or Trial (trial). |
| `version` | Version number of the API you are accessing (Current Version: v2). |
| `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). |
| `competitor_id` | Id of a given competitor. |
| `format` | xml or json. |
| `your_api_key` | Your API key. |
To retrieve the XML Schema Definition (.XSD) for the Competitor Profile, use the following URL.
https://schemas.sportradar.com/bsa/genericstage/v2/xml/endpoints/genericstage/competitor_profile.xsd
Return to top
## Deleted Stages
Provides all deleted stages within a given season.
```ruby
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://api.sportradar.com/indycar/trial/v2/en/seasons/sr:stage:660732/deleted_stages.xml?api_key={your_api_key}")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_body
```
```python
import http.client
conn = http.client.HTTPSConnection("api.sportradar.com")
conn.request("GET", "/indycar/trial/v2/en/seasons/sr:stage:660732/deleted_stages.xml?api_key={your_api_key}")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```shell
curl -X GET "https://api.sportradar.com/indycar/trial/v2/en/seasons/sr:stage:660732/deleted_stages.xml?api_key={your_api_key}"
```
> The above command returns xml structured like this.
Access the Deleted Stages feed by replacing the parameters in the following URL:
https://api.sportradar.com/indycar/`{access_level}`/`{version}`/`{language_code}`/seasons/`{stage_id}`/deleted_stages.`{format}`?api_key=`{your_api_key}`
| Parameter | Description |
| --------- | ----------- |
| `access_level` | Defines the access level of your API key as Production (production) or Trial (trial). |
| `version` | Version number of the API you are accessing (Current Version: v2). |
| `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). |
| `stage_id` | Id of a given stage. |
| `format` | xml or json. |
| `your_api_key` | Your API key. |
Return to top
## Seasons
Provides a complete historical list of available seasons. This is the starting point for the IndyCar API.
```ruby
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://api.sportradar.com/indycar/trial/v2/en/seasons.xml?api_key={your_api_key}")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_body
```
```python
import http.client
conn = http.client.HTTPSConnection("api.sportradar.com")
conn.request("GET", "/indycar/trial/v2/en/seasons.xml?api_key={your_api_key}")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```shell
curl -X GET "https://api.sportradar.com/indycar/trial/v2/en/seasons.xml?api_key={your_api_key}"
```
> The above command returns xml structured like this.
Access the Seasons feed by replacing the parameters in the following URL:
https://api.sportradar.com/indycar/`{access_level}`/`{version}`/`{language_code}`/seasons.`{format}`?api_key=`{your_api_key}`
| Parameter | Description |
| --------- | ----------- |
| `access_level` | Defines the access level of your API key as Production (production) or Trial (trial). |
| `version` | Version number of the API you are accessing (Current Version: v2). |
| `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). |
| `format` | xml or json. |
| `your_api_key` | Your API key. |
To retrieve the XML Schema Definition (.XSD) for the Seasons, use the following URL.
https://schemas.sportradar.com/bsa/genericstage/v2/xml/endpoints/genericstage/seasons.xsd
Return to top
## Stage Probabilities
Provides the outrights for each driver for a given race.
```ruby
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://api.sportradar.com/indycar/trial/v2/us/sport_events/sr:stage:351963/probabilities.xml?api_key={your_api_key}")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_body
```
```python
import http.client
conn = http.client.HTTPSConnection("api.sportradar.com")
conn.request("GET", "/indycar/trial/v2/us/sport_events/sr:stage:351963/probabilities.xml?api_key={your_api_key}")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```shell
curl -X GET "https://api.sportradar.com/indycar/trial/v2/us/sport_events/sr:stage:351963/probabilities.xml?api_key={your_api_key}"
```
> The above command returns xml structured like this.
Access the Stage Probabilities feed by replacing the parameters in the following URL:
https://api.sportradar.com/indycar/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{stage_id}`/probabilities.`{format}`?api_key=`{your_api_key}`
| Parameter | Description |
| --------- | ----------- |
| `access_level` | Defines the access level of your API key as Production (production) or Trial (trial). |
| `version` | Version number of the API you are accessing (Current Version: v2). |
| `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). |
| `stage_id` | Id of a given stage. |
| `format` | xml or json. |
| `your_api_key` | Your API key. |
To retrieve the XML Schema Definition (.XSD) for the Stage Probabilities, use the following URL.
https://schemas.sportradar.com/bsa/genericstage/v2/xml/endpoints/genericstage/probabilities.xsd
Return to top
## Stage Schedule
Provides the schedule for a given stage.
```ruby
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://api.sportradar.com/indycar/trial/v2/en/sport_events/sr:stage:348851/schedule.xml?api_key={your_api_key}")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_body
```
```python
import http.client
conn = http.client.HTTPSConnection("api.sportradar.com")
conn.request("GET", "/indycar/trial/v2/en/sport_events/sr:stage:348851/schedule.xml?api_key={your_api_key}")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```shell
curl -X GET "https://api.sportradar.com/indycar/trial/v2/en/sport_events/sr:stage:348851/schedule.xml?api_key={your_api_key}"
```
> The above command returns xml structured like this.
Access the Stage Schedule feed by replacing the parameters in the following URL:
https://api.sportradar.com/indycar/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{stage_id}`/schedule.`{format}`?api_key=`{your_api_key}`
| Parameter | Description |
| --------- | ----------- |
| `access_level` | Defines the access level of your API key as Production (production) or Trial (trial). |
| `version` | Version number of the API you are accessing (Current Version: v2). |
| `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). |
| `stage_id` | Id of a given stage. |
| `format` | xml or json. |
| `your_api_key` | Your API key. |
To retrieve the XML Schema Definition (.XSD) for the Stage Schedule, use the following URL.
https://schemas.sportradar.com/bsa/genericstage/v2/xml/endpoints/genericstage/schedule.xsd
Return to top
## Stage Summary
Provides schedules and results information based on the stage provided (season, event, practice, qualifying, qualifying part, or race).
```ruby
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://api.sportradar.com/indycar/trial/v2/en/sport_events/sr:stage:959327/summary.xml?api_key={your_api_key}")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_body
```
```python
import http.client
conn = http.client.HTTPSConnection("api.sportradar.com")
conn.request("GET", "/indycar/trial/v2/en/sport_events/sr:stage:959327/summary.xml?api_key={your_api_key}")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```shell
curl -X GET "https://api.sportradar.com/indycar/trial/v2/en/sport_events/sr:stage:959327/summary.xml?api_key={your_api_key}"
```
> Click here for a Summary sample of an Event.
> Click here for a Summary sample of a Practice.
> Click here for a Summary sample of a Qualifying stage.
> Click here for a Summary sample of a Qualifying Part.
> Click here for a Summary sample of a Race.
> Click here for a Summary sample of a Season.
> Click here for a Summary sample of a Sport.
Access the Stage Summary feed by replacing the parameters in the following URL:
https://api.sportradar.com/indycar/`{access_level}`/`{version}`/`{language_code}`/sport_events/`{stage_id}`/summary.`{format}`?api_key=`{your_api_key}`
| Parameter | Description |
| --------- | ----------- |
| `access_level` | Defines the access level of your API key as Production (production) or Trial (trial). |
| `version` | Version number of the API you are accessing (Current Version: v2). |
| `language_code` | Optional 2 letter code for supported languages: en (English), ru (Russian), and zh (simplified Chinese). |
| `stage_id` | Id of a given stage. |
| `format` | xml or json. |
| `your_api_key` | Your API key. |
To retrieve the XML Schema Definition (.XSD) for the Stage Summary, use the following URL.
https://schemas.sportradar.com/bsa/genericstage/v2/xml/endpoints/genericstage/summary.xsd
Return to top
## Frequently Asked Questions
| Quick Access | |
| Postman Collection | XSD Schema |
 |
Download |
| API | API Version |
| IndyCar | v2 |
| Note: Authentication is required for all API calls. |
Example:
>To find the win probabilities for a given race: >- Call the Seasons endpoint and find the Stage Id for the current season
- Call the Stage Schedule using the 'season' Stage Id
- Locate the Stage Id for the upcoming race
- Call the Stage Probabilities using the 'race' Stage Id
- Within the results locate the win probability for each racer
## Competitor Merge Mappings
Provides the valid Sportradar Id in cases when two competitors have been merged into one. Mapping entries will remain in the feed for 7 days.
| TTL / Cache: | 300 seconds | ||
| Update Frequency: | As Necessary | ||
| Content Type: | XML or JSON | ||
| Mappings Info Data Points: | Name | Merged Id | Retained Id |
| TTL / Cache: | 300 seconds | ||
| Update Frequency: | As Necessary | ||
| Content Type: | XML or JSON | ||
| Competitor Info Data Points: | Id Name Gender Nationality Country Code Official Website |
Weight Date of Birth Origin Country Origin Country Code |
Height Salary Place of Birth Debut First Points Date |
| TTL / Cache: | 300 seconds | ||
| Update Frequency: | As Necessary | ||
| Content Type: | Raw XML or JSON | ||
| Stage Information Data Points: | Description Disabled Scheduled |
Scheduled End Single Event |
Stage Id Type |
| TTL / Cache: | 300 seconds | ||
| Update Frequency: | As Necessary | ||
| Content Type: | XML or JSON | ||
| Category & Sport Information Data Points: | Category Id Category Name |
Sport Id | Sport Name |
| Stage Info Data Points: | Id Description |
Scheduled Scheduled End |
Type Single Event |
| TTL / Cache: | 300 seconds | ||
| Update Frequency: | As Necessary | ||
| Content Type: | XML or JSON | ||
| Category & Sport Information Data Points: | Category Id Category Name |
Sport Id | Sport Name |
| Competitor Info Data Points: | Id Name |
Gender Nationality |
Country Code |
| Stage Info Data Points: | Id Description Scheduled |
Scheduled End Type |
Status Single Event |
| Probability Info Data Points: | Market Description Market Name |
Market Type Outcome Id |
Outcome Name Outcome Probability |
| Venue Info Data Points: | City Country Country Code Coordinates Curves Left |
Curves Right Debut Id Length |
Name Official Website State Timezone |
| TTL / Cache: | 300 seconds | ||
| Update Frequency: | As Necessary | ||
| Content Type: | XML or JSON | ||
| Category & Sport Information Data Points: | Category Id Category Name |
Sport Id | Sport Name |
| Stage Info Data Points: | Id Description Scheduled |
Scheduled End Type |
Status Single Event |
| Venue Info Data Points: | City Country Country Code Coordinates Curves Left |
Curves Right Debut Id Length |
Name Official Website State Timezone |
|
Note: Results returned in a Summary endpoint will vary depending on the type of stage provided (season, event, practice, qualifying, qualifying part, or race). View our extended documentation for details or open the links in the right sidebar for samples. |
| TTL / Cache: | 300 seconds | ||
| Update Frequency: | As Necessary | ||
| Content Type: | XML or JSON | ||
| Category & Sport Information Data Points: | Category Id Category Name |
Sport Id | Sport Name |
| Competitor Info Data Points: | Country Code Gender |
Id Name |
Nationality |
| Stage Info Data Points: | Caution Laps Cautions Description Id |
Lead Changes Lead Drivers Scheduled Scheduled End |
Single Event Status Type |
| Results Info Data Points: | Average Speed Best Speed Car Number Fastest Lap Time Grid Laps Laps Led |
Lead Change Laps Podiums Points Pole Positions Position Races Races with Points |
Speed Status Gap Time Top 5 Top 10 Victories |
| Venue Info Data Points: | City Country Country Code Coordinates Curves Left |
Curves Right Debut Id Length |
Name Official Website State Timezone |
Q: What format are date fields presented in?
A: When we present date only values we present these in the ISO 8601 standard format.
ex: 2013-04-03
We use these for attributes that have date and no time (such as birthdate). For more information: https://en.wikipedia.org/wiki/ISO_8601
Q: What format are the date/time fields presented in?
A: All of our Date/Time attributes are in UTC, presented in the ISO 8601 standard format.
ex: 2013-04-03T18:15:00+00:00
For more information: https://en.wikipedia.org/wiki/ISO_8601
Q: How does the stage system work?
A: The IndyCar API uses generic stage implementation. The core of the API is built around the concept of stages. For example, an event contains the following stage types: practice, qualifying, and race. Each of those stages, in turn, have stages (except Practice which has no sub-stages). The IDs of each stage are usable in the URL path to request information about that particular stage. Qualifying stages contain sub-stages known as "Qualifying Parts". In the Race stages, the sub-stages are laps. You can use the lap stage ID in the URL to get specific lap details, including driver times, and position.
The IndyCar sport and seasons within it are stages as well. The sport stage consists of season stages for each annual season. Using the ID of a chosen season as a parameter in the Stage Summary endpoint you can "drill down" into each season. For example, using the 2018 season ID as a parameter in the Stage Summary endpoint, the sub-stages will be individual race events. From the race event, you can drill down into the practice, qualifying, race, and lap stages of a race using the same endpoint with different stage IDs.
The best way to "start" the navigation with the IndyCar API is using the Seasons endpoint. From there one can obtain the stage ID for the season required and use that as a parameter in the Stage Summary endpoint.
| Stage Type | Information Included | Sub-stages |
|---|---|---|
| Sport | Information about the seasons included. Which is limited to the current and previous season only. Note probabilities do not return valid data on this stage. | IndyCar seasons: 2017, 2018. |
| Season | Contains the season schedule, driver standings and statistics. | Events on the IndyCar calendar for that season. |
| Event | Information about a single event, the competitors, the teams, and the circuit. | Sessions (eg: Practice, Qualifying, Race) |
| Practice | Competitors and results of practice such as fastest time etc. | None |
| Qualifying | Information pertaining to the qualifying stage of the event including conditions, competitors, and overall qualifying results. | Qualifying Parts |
| Qualifying Part | Information about the individual qualifying parts of the overall qualifying stage such as conditions, competitors, and results. | None |
| Race | Details of the race itself including the competitors, lap by lap, and overall results. | Laps |
| Lap | Specific details on individual laps such as driver positions, times, etc. Note probabilities do not return valid data on this stage. | None. |
Q: What are the stage types I can expect to see in the feeds?
A: Here are the IndyCar stage:
- sport
- season
- event
- practice
- qualifying
- qualifying_part
- race
- lap
Q: How do I see the Championship points table?
A: Use the stage summary endpoint and a season stage ID as the parameter. The competitors node lists competitors, ranked with points, position, victories, races, races with points, and podiums.
Q: How do I know what "stage" I am currently looking at?
A: Each stage has a "stage" element. The stage element has an attribute "type" displays stage type. The different valid stage types are listed above.
Q: How do I get the probabilities for the entire Championship? Or only one race?
A: You can use season, event, and race stage IDs as parameters for the probabilities endpoint. Probabilities are available for the individual driver to win the season, a single event, and race stage. Probabilities are not available on the Sport, Practice, Qualifying, or Lap stages.
Q: How do I retrieve information about an individual driver?
A: Use the Competitor Profile endpoint with the required driver's competitor ID. The best place to get the driver's competitor ID is the Stage Summary endpoint, using the season stage ID.
Q: What races are covered in the IndyCar API?
A: The entire IndyCar Championship. For a more detailed breakdown, reference our Coverage Matrix.
Q: Is it updated in real-time?
A: No, post-event. Meaning results of practice are available after practice session is complete, similarly for qualification sessions and the race itself.
Q: Does this API include Qualifying and Practice sessions?
A: Yes, qualifying and practice sessions are updated post-event.
Q: What are the possible statuses of a race or stage?
A: Here are the possible stage statuses and their definitions:
- Cancelled - The stage is cancelled and will not be taking place
- Closed - The stage is over and we have validated the results
- Completed - The stage is over, but we have not finished data collection and validation
- Finished - The stage is over
- Not Started - The stage has not begun
- Preliminary - The stage is about to begin
- Running - The stage is currently in progress
Q: What unit of measurement is used for lap speed?
A: Beginning in 2023, the unit of measurement will be miles per hour. In previous seasons the data will be in kilometers per hour.
Q: What are the possible result statuses?
A: Here are the possible result statuses:
- Finished
- Out
Q: How do I locate the TTL (Time to Live)/cache on an API endpoint?
A: The cache (in seconds) can be accessed in the returned header information on each RESTful API call, under cache-control.
ex. cache-control: max-age=1, public, s-maxage=1 or
cache-control: public, must-revalidate, max-age=120
Return to top
Docs Navigation
- Documentation
- Football (American Football)
- Football (Soccer)
- Australian Rules Football
- Baseball
- Basketball
- NBA v8
- NBA v7
- NBA v5
- NBA v4
- WNBA v8
- WNBA v7
- WNBA v4
- WNBA v3
- NBA G League v8
- NBA G League v7
- NBA G League v5
- NCAA Men's Basketball v8
- NCAA Men's Basketball v7
- NCAA Men's Basketball v4
- NCAA Men's Basketball v3
- NCAA Women's Basketball v8
- NCAA Women's Basketball v7
- NCAA Women's Basketball v3
- Global Basketball v2
- Global Basketball v1
- NBA Historical v1
- Combat Sports
- Cricket
- Editorial Content
- Golf
- Handball
- Hockey
- Images
- Insights
- Insights User Interface
- NBA Insights v1
- NHL Insights v1
- MLB Insights v1
- NFL Insights v1
- MLB Betting Splits v2
- MLB Betting Splits v1
- NBA Betting Splits v2
- NBA Betting Splits v1
- NCAAFB Betting Splits v2
- NCAAFB Betting Splits v1
- NCAAMB Betting Splits v2
- NCAAMB Betting Splits v1
- NFL Betting Splits v2
- NFL Betting Splits v1
- NHL Betting Splits v2
- NHL Betting Splits v1
- Soccer Betting Splits v2
- Soccer Betting Splits v1
- Odds
- Broadcast Graphics
- Racing
- Rugby
- Tennis
- Widgets
- Baseline Sports Coverage
- Badminton v2
- Badminton v1
- Bandy v2
- Bandy v1
- Beach Soccer v2
- Beach Soccer v1
- Curling v2
- Curling v1
- Cycling v2
- Darts v2
- Darts v1
- Field Hockey v2
- Field Hockey v1
- Floorball v2
- Floorball v1
- Futsal v2
- Futsal v1
- Pesapallo v2
- Pesapallo v1
- Snooker v2
- Snooker v1
- Squash v2
- Squash v1
- Table Tennis v2
- Volleyball (Beach) v2
- Volleyball (Beach) v1
- Volleyball (Indoor) v2
- Volleyball (Indoor) v1
- Waterpolo v2
- Waterpolo v1
- Winter Sports v1
