NCAA Women's Basketball v8

Frequently Asked Questions
Quick Access
Postman Collection XSD Schema
Download
## NCAA Women's Basketball API Overview Sportradar’s NCAAWB API offers a comprehensive suite of game and seasonal stats to power your basketball experiences. All game data feeds update in real-time as games are played and are compiled via Sportradar‘s expert in-house operators. Real-time scoring is provided for all Division I games with live play-by-play for select games. Click here for additional coverage information. Primary feeds will return schedules, standings, team info, and real-time scores. Additional feeds provide complimentary data, including team rosters and Top 25 rankings.
API API Version Data Entry Workflow
NCAA Women's Basketball v8 Data Entry Workflow
Note: Authentication is required for all API calls.
## NCAA Women's Basketball API Map To best utilize the NCAA Women's Basketball API, you will need several parameters to create your API calls. The map below illustrates how you can obtain the parameters you need. >

Examples:

 >To find a team's leader in assists for a given game: >
  1. Call the schedule or daily schedule and find the Game Id for the chosen game
  2. Call the Game Boxscore using the Game Id
  3. Find the Team Assists Leader statistics and locate the player full_name attribute
>The name of the team's leader in assists is displayed. >To find the coach's name for a given team: >
  1. Call the season or series schedule and find id for the coach's team
  2. Call the Team Profile using the Team ID
  3. Find the coach element and locate the full_name attribute
>The coach's full name is displayed. The primary feeds require only a date or season to call the endpoints. Those feeds provide Game, Team, or Player Ids which can be used to generate the game, team, and player feeds. All of the other feeds require no variables.
Note: Tournament Ids are only listed in the Tournament List feed. Use the Tournament List to get the Ids required to access the Tournament Schedule and Tournament Summary.
## Coverage Levels We provide two different levels of detail to ensure maximum coverage. We combine coverage levels with the correct feeds to ensure you are getting the most comprehensive data offering in the most efficient manner possible. Full – We provide live play-by-play coverage for the entire game. We provide updated scores and time remaining as well as team and player level data in near real time.
Full coverage is available for:
  • All games featuring an AP Top 25 team
  • All "Power Five" (ACC, B1G, Big 12, Pac-12, SEC) Conference Tournament games
  • All Division I March Madness Tournament games
Extended Boxscore – We provide scores and time remaining, in a timely manner, as the game progresses. We provide team and player level data for the game within 120 minutes of the official results being posted. Extended Boxscore coverage is available for any game involving a Division I program, not covered via our full coverage offering. ## Daily Change Log Provides IDs and timestamps for teams, players, game statistics, schedules, and 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: XML or JSON
Game Data Point: Id
League Data Point: Season Id
Team Data Points: Id Market Name
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/league/2023/03/15/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.com") conn.request("GET", "/ncaawb/trial/v8/en/league/2023/03/15/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.com/ncaawb/trial/v8/en/league/2023/03/15/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.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/league/`{year}`/`{month}`/`{day}`/changes.`{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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `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. | Return to top ## Daily Schedule Date, time, location, and other event details for every match-up taking place in the league defined day.
Update Frequency: As Necessary
Content Type: XML or JSON
Game Data Points: Away Team Alias
Away Team Id
Away Team Name
Away Team Points
Broadcast Cable
Broadcast Internet 		Broadcast Network
Broadcast Radio
Broadcast Satellite
Broadcast Type
Conference Game
Game Coverage
Game Id
Game Status 		Game Title
Home Team Alias
Home Team Id
Home Team Name
Home Team Points
Neutral Site
Scheduled Date and Time
League Data Points: League Alias League Id League Name
Venue Data Points: Address
Capacity
City
Country 		Description
Latitude
Longitude
Name 		State
Venue Id
Zip
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/games/2023/03/16/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", "/ncaawb/trial/v8/en/games/2023/03/16/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/ncaawb/trial/v8/en/games/2023/03/16/schedule.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Daily Schedule feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/games/`{year}`/`{month}`/`{day}`/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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `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. | Return to top ## Game Boxscore Top-level team scores by quarter.
Update Frequency: As Necessary
Content Type: XML or JSON
Boxscore Data Points: Attendance
Lead Changes
Away Team Game Score
Away Team Id
Away Team Market
Away Team Name
Away Team Quarter Points
Away Team Rank
Away Team Remaining Timeouts
Game Quarter
Home Team Game Score 		Home Team Half Score
Home Team Id
Home Team Market
Home Team Name
Home Team Rank
Home Team Remaining Timeouts
Overtime Number
Overtime Points
Overtime Sequence
Quarter Number 		Quarter Points
Quarter Sequence
Team Assists Leader Player Full Name
Team Assists Leader Player Id
Team Points Leader Player Full Name
Team Points Leader Player Id
Team Rebounds Leader Player Full Name
Team Rebounds Leader Player Id
Times Tied
Game Data Points: Away Team Id
Away Team Points
Conference Game
Game Clock
Game Coverage 		Game Duration
Game Id
Game Status
Game Title 		Home Team Id
Neutral Site
Scheduled Date And Time
Player Game Statistics Data Points: Assists
Assists To Turnover Ratio
Blocked Attempts
Blocked Shots
Defensive Rebounds
Field Goals Attempts
Field Goals Made
Field Goals Percentage
Flagrant Fouls 		Free Throws Attempted
Free Throws Made
Free Throws Percentage
Minutes Played
Offensive Rebounds
Personal Fouls
Plus/Minus
Points
Rebounds 		Steals
Technical Fouls
Three Points Attempts
Three Points Made
Three Points Percentage
Turnovers
Two Points Attempted
Two Points Made
Two Points Percentage
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/games/113e5928-c64a-4f4e-8580-22a6b07bd2c1/boxscore.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", "/ncaawb/trial/v8/en/games/113e5928-c64a-4f4e-8580-22a6b07bd2c1/boxscore.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/ncaawb/trial/v8/en/games/113e5928-c64a-4f4e-8580-22a6b07bd2c1/boxscore.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Game Boxscore feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/games/`{game_id}`/boxscore.`{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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `game_id` | ID for a given game. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Game Summary Top-level boxscore information along with detailed game stats at the team and player levels.
Update Frequency: As Necessary
Content Type: XML or JSON
Boxscore Data Points: Attendance
Lead Changes
Away Team Game Score
Away Team Id
Away Team Market
Away Team Name
Away Team Quarter Points
Away Team Rank
Away Team Remaining Timeouts
Game Quarter
Home Team Game Score 		Home Team Half Score
Home Team Id
Home Team Market
Home Team Name
Home Team Rank
Home Team Remaining Timeouts
Lineup Active For Game
Lineup Ejected
Lineup Fouled Out
Lineup Played
Lineup Started		 Overtime Number
Overtime Points
Overtime Sequence
Quarter Number
Quarter Points
Quarter Sequence
Times Tied
Game Data Points: Away Team Id
Away Team Points
Conference Game
Game Clock
Game Coverage 		Game Duration
Game Id
Game Status
Game Title 		Home Team Id
Neutral Site
Scheduled Date And Time
Player Information Data Points: First Name
Full Name
Id 		Jersey Number
Last Name 		Position
Primary Position
Team Information Data Points: Alias
Home Flag 		Id
Market 		Name
Venue Information Data Points: Address
Capacity
City 		Country
Description
Name 		State or Province
Venue Id
Zip
Player Game Statistics Data Points: Assists
Assists To Turnover Ratio
Blocked Attempts
Blocked Shots
Defensive Rebounds
Field Goals Attempts
Field Goals Made
Field Goals Percentage
Flagrant Fouls 		Free Throws Attempted
Free Throws Made
Free Throws Percentage
Minutes Played
Offensive Rebounds
Personal Fouls
Plus/Minus
Points
Rebounds 		Steals
Technical Fouls
Three Points Attempts
Three Points Made
Three Points Percentage
Turnovers
Two Points Attempted
Two Points Made
Two Points Percentage
Team Game Statistics Data Points: Assists
Assists To Turnover Ratio
Blocked Attempts
Blocked Shots
Coach Technical Fouls
Defensive Rebounds
Ejections
Fast Break Points
Field Goals Attempts
Field Goals Made
Field Goals Percentage
Flagrant Fouls 		Fouled Out
Free Throws Attempted
Free Throws Made
Free Throws Percentage
Minutes Played
Offensive Rebounds
Personal Fouls
Personal Rebounds
Player Technical Fouls
Player Turnovers
Points
Points in the Paint
Points off Turnovers 		Second Chance Points
Steals
Team Defensive Rebounds
Team Offensive Rebounds
Team Rebounds
Team Technical Fouls
Team Turnovers
Three Points Attempts
Three Points Made
Three Points Percentage
Total Rebounds
Total Turnovers
Two Points Attempted
Two Points Made
Two Points Percentage
Player Period Statistics Data Points: Assists
Assists To Turnover Ratio
Blocked Attempts
Blocked Shots
Defensive Rebounds
Effective Field Goal Percentage
Efficiency
Efficiency Game Score
Field Goal Attempts
Field Goal Percentage
Field Goals Made
Flagrant Fouls
Fouls Drawn
Free Throw Attempts 		Free Throw Percentage
Free Throws Made
Id
Minutes Played
Number
Offensive Fouls
Offensive Rebounds
Personal Fouls
Plus/Minus
Points
Points in the Paint
Points in the Paint Attempts
Points in the Paint Percentage
Points in the Paint Made
Points Off Turnovers
Rebounds 		Second Chance Points
Sequence
Steals
Technical Fouls
Three Point Attempts
Three Point Percentage
Three Points Made
True Shooting Attempts
True Shooting Percentage
Turnovers
Two Point Attempts
Two Point Percentage
Two Points Made
Type
Team Period Statistics Data Points: Assists
Assists To Turnover Ratio
Bench Points
Biggest Lead
Blocked Attempts
Blocked Shots
Coach Technical Fouls
Defensive Rebounds
Effective Field Goal Percentage
Efficiency
Efficiency Game Score
Field Goal Attempts
Field Goal Percentage
Field Goals Made
Flagrant Fouls
Fouls Drawn
Free Throw Attempts 		Free Throw Percentage
Free Throws Made
Id
Minutes Played
Number
Offensive Fouls
Offensive Rebounds
Personal Fouls
Player Technical Fouls
Plus/Minus
Points
Points Against
Points in the Paint
Points in the Paint Attempts
Points in the Paint Percentage
Points in the Paint Made
Points off Turnovers
Rebounds 		Second Chance Points
Sequence
Steals
Team Rebounds
Team Technical Fouls
Team Turnovers
Three Point Attempts
Three Point Percentage
Three Points Made
True Shooting Attempts
True Shooting Percentage
Turnovers
Two Point Attempts
Two Point Percentage
Two Points Made
Type
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/games/427cd293-583e-42d9-b350-6b7cfff4ae4e/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", "/ncaawb/trial/v8/en/games/427cd293-583e-42d9-b350-6b7cfff4ae4e/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/ncaawb/trial/v8/en/games/427cd293-583e-42d9-b350-6b7cfff4ae4e/summary.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Game Summary feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/games/`{game_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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `game_id` | ID for a given game. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## League Hierarchy League, conference, division, and team identification and association information.
Update Frequency: As Necessary
Content Type: XML or JSON
League Data Points: Conference Alias
Conference Id
Conference Name 		Division Alias
Division Id
Division Name 		League Alias
League Id
League Name
Team Data Points: Alias
Id 		Market Name
Venue Data Points: Address
Capacity
City
Country 		Description
Latitude
Longitude
Name 		State
Venue Id
Zip
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/league/hierarchy.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", "/ncaawb/trial/v8/en/league/hierarchy.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/ncaawb/trial/v8/en/league/hierarchy.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the League Hierarchy feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/league/hierarchy.`{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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## League Leaders NCAA leader information for various offensive and defensive categories including full player seasonal statistics for each player in each category.
Update Frequency: As Necessary
Content Type: XML or JSON
League Data Points: Season Id Season Type Season Year
League Leaders Data Points: Assists
Assists Per Game
Blocked Shots
Blocked Shots Per Game
Category Name
Category Type
Field Goal Percentage
Free Throw Percentage
Minutes Played 		Minutes Played Per Game
Offensive Rebounds
Personal Fouls
Personal Fouls Per Game
Player Rank
Points
Points Per Game
Rebounds
Rebounds Per Game 		Stat Category
Steals
Steals Per Game
Three Point Percentage
Tied Flag
Turnovers
Turnovers Per Game
Two Point Percentage
Player Data Points: First Name
Full Name
Id 		Jersey Number
Last Name 		Position
Primary Position
Player Season Statistics Data Points: Assists
Assists Per Game
Assists to Turnover Ratio
Blocked Attempts
Blocked Attempts Per Game
Blocked Shots
Blocked Shots Per Game
Defensive Rebounds
Defensive Rebounds Per Game
Efficiency
Efficiency Per Game
Ejections
Field Goal Attempts
Field Goal Attempts Per Game
Field Goal Percentage
Field Goals Made
Field Goals Made Per Game
Flagrant Fouls
Flagrant Fouls Per Game
Foul Outs 		Free Throw Attempts
Free Throw Attempts Per Game
Free Throw Percentage
Free Throws Made
Free Throws Made Per Game
Games Played
Games Started
Minutes Played
Minutes Played Per Game
Offensive Rebounds
Offensive Rebounds Per Game
Personal Fouls
Personal Fouls Per Game
Points
Points Per Game
Rebounds 		Rebounds Per Game
Steals
Steals Per Game
Technical Fouls
Three Point Attempts
Three Point Attempts Per Game
Three Point Percentage
Three Points Made
Three Points Made Per Game
True Shooting Attempts
True Shooting Attempts Per Game
True Shooting Percentage
Turnovers
Turnovers Per Game
Two Point Attempts
Two Point Attempts Per Game
Two Point Percentage
Two Points Made
Two Points Made Per Game
Team Data Points: Id Market Name
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/seasons/2023/REG/99eadefa-6b4d-43f1-a176-76cbd034bfdb/leaders.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", "/ncaawb/trial/v8/en/seasons/2023/REG/99eadefa-6b4d-43f1-a176-76cbd034bfdb/leaders.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/ncaawb/trial/v8/en/seasons/2023/REG/99eadefa-6b4d-43f1-a176-76cbd034bfdb/leaders.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the League Leaders feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_year}`/`{ncaawb_season}`/`{division/conference}`/leaders.`{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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `season_year` | Year in 4 digit format (YYYY). | | `ncaawb_season` | Regular Season (REG), Conference Tournament (CT), or Postseason (PST). | | `division/conference` | ID for a given division or conference. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Play-By-Play Detailed, real-time information on every team possession and game event.
Update Frequency: As Necessary
Content Type: XML or JSON
Boxscore Data Points: Attendance
Away Team Game Score
Away Team Quarter Points
Away Team Rank
Away Team Remaining Timeouts
Game Quarter
Home Team Game Score 		Home Team Quarter Points
Home Team Rank
Home Team Remaining Timeouts
Lead Changes
Overtime Id
Overtime Number 		Overtime Sequence
Quarter Id
Quarter Number
Quarter Sequence
Times Tied
Game Data Points: Away Team Alias
Away Team Id
Away Team Market
Away Team Name
Conference Game
Game Clock 		Game Coverage
Game Duration
Game Id
Game Status
Game Title 		Home Team Alias
Home Team Id
Home Team Market
Home Team Name
Neutral Site
Scheduled Date And Time
Player Information Data Points: Full Name Id Jersey Number
Team Information Data Points: Id Market Name
Play-By-Play Data Points: Attributed Basket Team is Defending
Attributed Team Id
Attributed Team Market
Attributed Team Name
Event Attempt
Event Away Points
Event Clock
Event Description
Event Home Points
Event Id
Event Location X Coordinate
Event Location Y Coordinate
Event Participants Player Full Name 		Event Participants Player Id
Event Participants Player Jersey Number
Event Participants Team Id
Event Participants Team Market
Event Participants Team Name
Event Sequence
Event Turnover Type
Event Type
Event Updated
Fieldgoal Made Flag
Fieldgoal Points 		Fieldgoal Shot Type
Fieldgoal Shot Type Description
Fieldgoal Three Point Shot
Freethrow Free Throw Type
Freethrow Made Flag
Freethrow Points
Possession Team Id
Possession Team Market
Possession Team Name
Rebound Rebound Type
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/games/113e5928-c64a-4f4e-8580-22a6b07bd2c1/pbp.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", "/ncaawb/trial/v8/en/games/113e5928-c64a-4f4e-8580-22a6b07bd2c1/pbp.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/ncaawb/trial/v8/en/games/113e5928-c64a-4f4e-8580-22a6b07bd2c1/pbp.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Play-By-Play feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/games/`{game_id}`/pbp.`{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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `game_id` | ID for a given game. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Player Profile Provides player biographical information and seasonal statistics.
Update Frequency: As Necessary
Content Type: XML or JSON
League Data Points: League Alias
League Id 		League Name
Season Id 		Season Type
Season Year
Player Data Points: Abbreviated Name
Birth Place
Experience
First Name 		Full Name
Height (in)
Id
Jersey Number 		Last Name
Position
Primary Position
Status
Updated
Player Season Statistics Data Points: Assists
Assists Per Game
Assists to Turnover Ratio
Blocked Attempts
Blocked Attempts Per Game
Blocked Shots
Blocked Shots Per Game
Defensive Rebounds
Defensive Rebounds Per Game
Efficiency
Efficiency Per Game
Ejections
Field Goal Attempts
Field Goal Attempts Per Game
Field Goal Percentage
Field Goals Made
Field Goals Made Per Game
Flagrant Fouls
Flagrant Fouls Per Game
Foul Outs 		Free Throw Attempts
Free Throw Attempts Per Game
Free Throw Percentage
Free Throws Made
Free Throws Made Per Game
Games Played
Games Started
Minutes Played
Minutes Played Per Game
Offensive Rebounds
Offensive Rebounds Per Game
Personal Fouls
Personal Fouls Per Game
Points
Points Per Game
Rebounds 		Rebounds Per Game
Steals
Steals Per Game
Technical Fouls
Three Point Attempts
Three Point Attempts Per Game
Three Point Percentage
Three Points Made
Three Points Made Per Game
True Shooting Attempts
True Shooting Attempts Per Game
True Shooting Percentage
Turnovers
Turnovers Per Game
Two Point Attempts
Two Point Attempts Per Game
Two Point Percentage
Two Points Made
Two Points Made Per Game
Team Data Points: Alias
Id 		Market Name
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/players/d8f2f455-ee4e-4061-8d1d-bd04131bd9a4/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", "/ncaawb/trial/v8/en/players/d8f2f455-ee4e-4061-8d1d-bd04131bd9a4/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/ncaawb/trial/v8/en/players/d8f2f455-ee4e-4061-8d1d-bd04131bd9a4/profile.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Player Profile feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/players/`{player_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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `player_id` | ID for a given player. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Rankings (Current Week) List of current Associated Press and USA Today rankings, including those teams not ranked but receiving votes.
Update Frequency: As Necessary
Content Type: XML or JSON
Rankings Data Points: Effective Date
First Place Votes
Poll Alias
Poll Id 		Poll Name
Poll Points
Poll Rank 		Votes
Week
Year
Team Data Points: Id Market Name
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/polls/AP/2022/rankings.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", "/ncaawb/trial/v8/en/polls/AP/2022/rankings.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/ncaawb/trial/v8/en/polls/AP/2022/rankings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Rankings feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/polls/`{poll_name}`/`{season_year}`/rankings.`{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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `poll_name` | Abbreviated 2 letter name of the poll: Associated Press (AP), USA Today (US). | | `season_year` | Year in 4 digit format (YYYY). | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Rankings (By Week) List by week of Associated Press and USA Today rankings, including those teams not ranked but receiving votes.
Update Frequency: As Necessary
Content Type: XML or JSON
Rankings Data Points: Effective Date
First Place Votes
Poll Alias
Poll Id 		Poll Name
Poll Points
Poll Rank 		Votes
Week
Year
Team Data Points: Id Market Name
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/polls/AP/2022/W15/rankings.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", "/ncaawb/trial/v8/en/polls/AP/2022/W15/rankings.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/ncaawb/trial/v8/en/polls/AP/2022/W15/rankings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Rankings By Week feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/polls/`{poll_name}`/`{season_year}`/`{ncaawb_week}`/rankings.`{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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `poll_name` | Abbreviated 2 letter name of the poll: Associated Press (AP), USA Today (US). | | `season_year` | Year in 4 digit format (YYYY). | | `ncaawb_week` | Week number in 1-2 digit format after a W (W14). Alternatively, PRE can be used for Pre-season, PST for Post-season, or PSTF Post-season final (USA Today only). | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## RPI Rankings (Daily) RPI information including rating, strength of schedule, ranking, and records based on the Sportradar’s RPI calculations.
Update Frequency: As Necessary
Content Type: XML or JSON
League Data Points: Season Id Season Type Season Year
Rankings Data Point: Team Rank
Standings Data Points: Adjusted Winning Pct
Away Losses
Away Wins
Home Losses
Home Wins
Neutral Site Losses
Neutral Site Wins
Opponent Losses
Opponent's Opponent's Winning Percentage
Opponent’s Ranked 1-25 Losses 		Opponent’s Ranked 1-25 Wins
Opponent’s Ranked 1-50 Losses
Opponent’s Ranked 1-50 Wins
Opponent’s Ranked 101-150 Losses
Opponent’s Ranked 101-150 Wins
Opponent’s Ranked 151+ Losses
Opponent’s Ranked 151+ Wins
Opponent’s Ranked 26-50 Losses
Opponent’s Ranked 26-50 Wins 		Opponent’s Ranked 51-100 Losses
Opponent’s Ranked 51-100 Wins
Opponent’s RPI Rank (Range)
Opponent's Winning Percentage
Opponent Wins
Overall Losses
Overall Wins
RPI Rating
Strength Of Schedule
Team Data Points: Id Market Name
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/rpi/2022/rankings.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", "/ncaawb/trial/v8/en/rpi/2022/rankings.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/ncaawb/trial/v8/en/rpi/2022/rankings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the RPI Rankings feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/rpi/`{season_year}`/rankings.`{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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `season_year` | Year in 4 digit format (YYYY). | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Schedule Date, time, location, and other event details for every match-up taking place in the full league season.
Update Frequency: As Necessary
Content Type: XML or JSON
Game Data Points: Away Team Alias
Away Team Id
Away Team Name
Away Team Points
Broadcast Cable
Broadcast Internet 		Broadcast Network
Broadcast Radio
Broadcast Satellite
Broadcast Type
Conference Game
Game Coverage
Game Id
Game Status 		Game Title
Home Team Alias
Home Team Id
Home Team Name
Home Team Points
Neutral Site
Scheduled Date and Time
League Data Points: League Alias
League Id 		League Name
Season Id 		Season Type
Season Year
Venue Data Points: Address
Capacity
City
Country 		Description
Latitude
Longitude
Name 		State
Venue Id
Zip
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/games/2022/pst/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", "/ncaawb/trial/v8/en/games/2022/pst/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/ncaawb/trial/v8/en/games/2022/pst/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.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/games/`{season_year}`/`{ncaawb_season}`/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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `season_year` | Year in 4 digit format (YYYY). | | `ncaawb_season` | Conference Tournament (CT), Regular Season (REG), or Postseason (PST). | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Seasonal Statistics Detailed team and player statistics for the defined season.
Update Frequency: As Necessary
Content Type: XML or JSON
League Information Data Points: Season Id Season Type Season Year
Player Information Data Points: First Name
Full Name
Id 		Jersey Number
Last Name 		Position
Primary Position
Team Information Data Points: Id Market Name
Opponents Seasonal Statistics Data Points: Assists
Assists Per Game
Assists To Turnover Ratio
Blocked Attempts
Blocked Attempts Per Game
Blocked Shots
Blocked Shots Per Game
Defensive Rebounds
Defensive Rebounds Per Game
Ejections
Fast Break Points
Fast Break Points Per Game
Field Goals Attempted
Field Goals Attempted Per Game
Field Goals Made
Field Goals Made Per Game
Field Goals Percentage
Flagrant Fouls
Flagrant Fouls Per Game 		Foul Outs
Free Throws Attempted
Free Throws Attempted Per Game
Free Throws Made
Free Throws Made Per Game
Free Throws Percentage
Games Played
Minutes Played
Minutes Played Per Game
Offensive Rebounds
Offensive Rebounds Per Game
Personal Fouls
Personal Fouls Per Game
Points
Points in the Paint
Points in the Paint Per Game
Points off Turnovers
Points off Turnovers Per Game
Points Per Game 		Rebounds
Rebounds Per Game
Second Chance Points
Second Chance Points per Game
Steals
Steals Per Game
Technical Fouls
Three Points Attempted
Three Points Attempted Per Game
Three Points Made
Three Points Made Per Game
Three Points Percentage
Turnovers
Turnovers Per Game
Two Points Attempted
Two Points Attempted Per Game
Two Points Made
Two Points Made Per Game
Two Points Percentage
Player Seasonal Statistics Data Points: Assists
Assists Per Game
Assists to Turnover Ratio
Blocked Attempts
Blocked Attempts Per Game
Blocked Shots
Blocked Shots Per Game
Defensive Rebounds
Defensive Rebounds Per Game
Ejections
Field Goals Attempted
Field Goals Attempted Per Game
Field Goals Made
Field Goals Made Per Game
Field Goals Percentage
Flagrant Fouls
Flagrant Fouls Per Game 		Foul Outs
Free Throws Attempted
Free Throws Attempted Per Game
Free Throws Made
Free Throws Made Per Game
Free Throws Percentage
Games Played
Games Started
Minutes Played
Minutes Played Per Game
Offensive Rebounds
Offensive Rebounds Per Game
Personal Fouls
Personal Fouls Per Game
Points
Points Per Game
Rebounds 		Rebounds Per Game
Steals
Steals Per Game
Technical Fouls
Three Points Attempted
Three Points Attempted Per Game
Three Points Made
Three Points Made Per Game
Three Points Percentage
Turnovers
Turnovers Per Game
Two Points Attempted
Two Points Attempted Per Game
Two Points Made
Two Points Made Per Game
Two Points Percentage
Team Seasonal Statistics Data Points: Assists
Assists Per Game
Assists To Turnover Ratio
Blocked Attempts
Blocked Attempts Per Game
Blocked Shots
Blocked Shots Per Game
Defensive Rebounds
Defensive Rebounds Per Game
Ejections
Fast Break Points
Fast Break Points Per Game
Field Goals Attempted
Field Goals Attempted Per Game
Field Goals Made
Field Goals Made Per Game
Field Goals Percentage
Flagrant Fouls
Flagrant Fouls Per Game 		Foul Outs
Free Throws Attempted
Free Throws Attempted Per Game
Free Throws Made
Free Throws Made Per Game
Free Throws Percentage
Games Played
Minutes Played
Minutes Played Per Game
Offensive Rebounds
Offensive Rebounds Per Game
Personal Fouls
Personal Fouls Per Game
Points
Points in the Paint
Points in the Paint Per Game
Points off Turnovers
Points off Turnovers Per Game
Points Per Game 		Rebounds
Rebounds Per Game
Second Chance Points
Second Chance Points per Game
Steals
Steals Per Game
Technical Fouls
Three Points Attempted
Three Points Attempted Per Game
Three Points Made
Three Points Made Per Game
Three Points Percentage
Turnovers
Turnovers Per Game
Two Points Attempted
Two Points Attempted Per Game
Two Points Made
Two Points Made Per Game
Two Points Percentage
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/seasons/2022/REG/teams/f383d855-f0e2-4114-a8f0-bc75647e1bd6/statistics.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", "/ncaawb/trial/v8/en/seasons/2022/REG/teams/f383d855-f0e2-4114-a8f0-bc75647e1bd6/statistics.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/ncaawb/trial/v8/en/seasons/2022/REG/teams/f383d855-f0e2-4114-a8f0-bc75647e1bd6/statistics.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Seasonal Statistics feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/seasontd/`{season_year}`/`{ncaawb_season}`/teams/`{team_id}`/statistics.`{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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `season_year` | Year in 4 digit format (YYYY). | | `ncaawb_season` | Conference Tournament (CT), Regular Season (REG), or Postseason (PST). | | `team_id` | ID for a given team. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Seasons Provides a list of all available seasons.
Update Frequency: As Necessary
Content Type: XML or JSON
League Info Data Points: League Alias
League Id
League Name
Season End Date		 Season Id
Season Start Date
Season Status 		Season Type Code
Season Type Name
Season Year
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/league/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", "/ncaawb/trial/v8/en/league/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/ncaawb/trial/v8/en/league/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/ncaawb/`{access_level}`/`{version}`/`{language_code}`/league/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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Standings Detailed team records across various views including, overall, conference, and division information.
Update Frequency: As Necessary
Content Type: XML or JSON
League Data Points: Conference Alias
Conference Id
Conference Name 		League Alias
League Id
League Name 		Season Id
Season Type
Season Year
Standings Data Points: Conference Losses
Conference Winning Percentage
Conference Wins
Games Behind Conference
Games Decided by 10 pts or More Losses
Games Decided by 10 pts or More Winning Percentage
Games Decided by 10 pts or More Wins
Games Decided by 3 pts or Less Losses
Games Decided by 3 pts or Less Winning Percentage
Games Decided by 3 pts or Less Wins
Home Losses
Home Winning Percentage
Home Wins
Last 10 Games Losses
Last 10 Games Winning Percentage
Last 10 Games Wins
Last 10 Home Games Losses
Last 10 Home Games Winning Percentage
Last 10 Home Games Wins
Last 10 Road Games Losses
Last 10 Road Games Winning Percentage
Last 10 Road Games Wins
Overall Losses
Overall Point Differential
Overall Points Against
Overall Points For
Overall Winning Percentage
Overall Wins
Overtime Losses
Overtime Winning Percentage
Overtime Wins
Road Losses
Road Winning Percentage
Road Wins
Streak
Versus ACC Losses
Versus ACC Winning Percentage
Versus ACC Wins
Versus America Athletic Losses
Versus America Athletic Winning Percentage
Versus America Athletic Wins
Versus America East Losses
Versus America East Winning Percentage
Versus America East Wins
Versus Atlantic 10 Losses
Versus Atlantic 10 Winning Percentage
Versus Atlantic 10 Wins 		Versus Atlantic Sun Losses
Versus Atlantic Sun Winning Percentage
Versus Atlantic Sun Wins
Versus Big 12 Losses
Versus Big 12 Winning Percentage
Versus Big 12 Wins
Versus Big East Losses
Versus Big East Winning Percentage
Versus Big East Wins
Versus Big Sky Losses
Versus Big Sky Winning Percentage
Versus Big Sky Wins
Versus Big South Losses
Versus Big South Winning Percentage
Versus Big South Wins
Versus Big Ten Losses
Versus Big Ten Winning Percentage
Versus Big Ten Wins
Versus Big West Losses
Versus Big West Winning Percentage
Versus Big West Wins
Versus Colonial Losses
Versus Colonial Winning Percentage
Versus Colonial Wins
Versus Conference USA Losses
Versus Conference USA Winning Percentage
Versus Conference USA Wins
Versus Horizon Losses
Versus Horizon Winning Percentage
Versus Horizon Wins
Versus Independents Losses
Versus Independents Winning Percentage
Versus Independents Wins
Versus Ivy League Losses
Versus Ivy League Winning Percentage
Versus Ivy League Wins
Versus MAAC Losses
Versus MAAC Winning Percentage
Versus MAAC Wins
Versus MEAC Losses
Versus MEAC Winning Percentage
Versus MEAC Wins
Versus Mid-American Losses
Versus Mid-American Winning Percentage
Versus Mid-American Wins
Versus Missouri Valley Losses
Versus Missouri Valley Winning Percentage 		Versus Missouri Valley Wins
Versus Mountain West Losses
Versus Mountain West Winning Percentage
Versus Mountain West Wins
Versus Northeast Losses
Versus Northeast Winning Percentage
Versus Northeast Wins
Versus Ohio Valley Losses
Versus Ohio Valley Winning Percentage
Versus Ohio Valley Wins
Versus PAC-12 Losses
Versus PAC-12 Winning Percentage
Versus PAC-12 Wins
Versus Patriot League Losses
Versus Patriot League Winning Percentage
Versus Patriot League Wins
Versus SEC Losses
Versus SEC Winning Percentage
Versus SEC Wins
Versus Southern Losses
Versus Southern Winning Percentage
Versus Southern Wins
Versus Southland Losses
Versus Southland Winning Percentage
Versus Southland Wins
Versus Summit League Losses
Versus Summit League Winning Percentage
Versus Summit League Wins
Versus Sun Belt Losses
Versus Sun Belt Winning Percentage
Versus Sun Belt Wins
Versus SWAC Losses
Versus SWAC Winning Percentage
Versus SWAC Wins
Versus Teams Above 500 Losses
Versus Teams Above 500 Winning Percentage
Versus Teams Above 500 Wins
Versus Teams Below 500 Losses
Versus Teams Below 500 Winning Percentage
Versus Teams Below 500 Wins
Versus WAC Losses
Versus WAC Winning Percentage
Versus WAC Wins
Versus West Coast Losses
Versus West Coast Winning Percentage
Versus West Coast Wins
Team Data Points: Id Market Name
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/seasons/2022/REG/standings.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", "/ncaawb/trial/v8/en/seasons/2022/REG/standings.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/ncaawb/trial/v8/en/seasons/2022/REG/standings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Standings feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_year}`/`{ncaawb_season}`/standings.`{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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `season_year` | Year in 4 digit format (YYYY). | | `ncaawb_season` | Conference Tournament (CT), Regular Season (REG), or Postseason (PST). | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Team Profiles (Rosters) Detailed team information including league affiliation information as well as player roster information.
Update Frequency: As Necessary
Content Type: XML or JSON
League Data Points: Conference Alias
Conference Id
Conference Name 		Division Alias
Division Id
Division Name 		League Alias
League Id
League Name
Team Data Points: Alias
Coach Experience
Coach First Name
Coach Full Name 		Coach Id
Coach Last Name
Coach Position
Id 		Market
Name
Year Founded
Venue Data Points: Address
Capacity
City
Country 		Description
Latitude
Longitude
Name 		State
Venue Id
Zip
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/teams/4cd320c7-6f56-4448-bf6e-afeb1aba579c/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", "/ncaawb/trial/v8/en/teams/4cd320c7-6f56-4448-bf6e-afeb1aba579c/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/ncaawb/trial/v8/en/teams/4cd320c7-6f56-4448-bf6e-afeb1aba579c/profile.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Team Profile feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/teams/`{team_id}`/profile.`{format}`?api_key=`{your_api_key}` | Parameter | Description | | --------- | ----------- | | `access_level` | Defines the access level of your API key as Production (production) or Trial (trial). | | `version` | Version number of the API you are accessing (Current Version: v8). | | `team_id` | ID for a given team. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Tournament List Summarized list of all tournaments scheduled for the given season including tournament name, location, start date, and end date.
Update Frequency: As Necessary
Content Type: XML or JSON
League Data Points: League Alias
League Id 		League Name
Season Id 		Season Type
Season Year
Tournament Data Points: End Date
Start Date 		Status
Id 		Location
Name
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/tournaments/2022/pst/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", "/ncaawb/trial/v8/en/tournaments/2022/pst/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/ncaawb/trial/v8/en/tournaments/2022/pst/schedule.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Tournament List feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/tournaments/`{season_year}`/`{ncaawb_season}`/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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `season_year` | Year in 4 digit format (YYYY). | | `ncaawb_season` | Conference Tournament (CT), Regular Season (REG), or Postseason (PST). | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Tournament Schedule Date, time, location, and other event details for every match-up taking place for a given tournament.
Update Frequency: As Necessary
Content Type: XML or JSON
Game Data Points: Away Team Previous Tournament Game Away Team
Away Team Previous Tournament Game Coverage
Away Team Previous Tournament Game Home Team
Away Team Previous Tournament Game Id
Away Team Previous Tournament Game Outcome
Away Team Previous Tournament Game Scheduled Date and Time
Away Team Previous Tournament Game Status
Away Team Previous Tournament Game Title
Away Team Alias
Away Team Id
Away Team Name
Away Team Points 		Away Team Seed Number
Broadcast Cable
Broadcast Internet
Broadcast Network
Broadcast Radio
Broadcast Satellite
Broadcast Type
Conference Game
Coverage
Id
Status
Title
Home Team Previous Tournament Game Away Team
Home Team Previous Tournament Game Coverage 		Home Team Previous Tournament Game Home Team
Home Team Previous Tournament Game Id
Home Team Previous Tournament Game Outcome
Home Team Previous Tournament Game Scheduled Date and Time
Home Team Previous Tournament Game Status
Home Team Previous Tournament Game Title
Home Team Alias
Home Team Id
Home Team Name
Home Team Points
Home Team Seed Number
Neutral Site
Scheduled Date and Time
League Data Points: League Alias League Id League Name
Tournament Data Points: Bracket Id
Bracket Location
Bracket Name
Bracket Rank 		Round Id
Round Name
Round Sequence
Status 		Id
Location
Name
Venue Data Points: Address
Capacity
City
Country 		Description
Latitude
Longitude
Name 		State
Venue Id
Zip
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/tournaments/9af41eec-ebc0-4ac2-bd6c-53625c6b4522/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", "/ncaawb/trial/v8/en/tournaments/9af41eec-ebc0-4ac2-bd6c-53625c6b4522/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/ncaawb/trial/v8/en/tournaments/9af41eec-ebc0-4ac2-bd6c-53625c6b4522/schedule.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Tournament Schedule feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/tournaments/`{tournament_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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `tournament_id` | ID for a given tournament. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Tournament Statistics Detailed team and player statistics for the defined tournament.
Update Frequency: As Necessary
Content Type: XML or JSON
Tournament Information Data Points: Status
Tournament Id 		Tournament Location Tournament Name
Player Information Data Points: First Name
Full Name
Id 		Jersey Number
Last Name 		Position
Primary Position
Team Information Data Points: Id Market Name
Opponents Seasonal Statistics Data Points: Assists
Assists Per Game
Assists To Turnover Ratio
Blocked Attempts
Blocked Attempts Per Game
Blocked Shots
Blocked Shots Per Game
Defensive Rebounds
Defensive Rebounds Per Game
Ejections
Fast Break Points
Fast Break Points Per Game
Field Goals Attempted
Field Goals Attempted Per Game
Field Goals Made
Field Goals Made Per Game
Field Goals Percentage
Flagrant Fouls
Flagrant Fouls Per Game 		Foul Outs
Free Throws Attempted
Free Throws Attempted Per Game
Free Throws Made
Free Throws Made Per Game
Free Throws Percentage
Games Played
Minutes Played
Minutes Played Per Game
Offensive Rebounds
Offensive Rebounds Per Game
Personal Fouls
Personal Fouls Per Game
Points
Points in the Paint
Points in the Paint Per Game
Points off Turnovers
Points off Turnovers Per Game
Points Per Game 		Rebounds
Rebounds Per Game
Second Chance Points
Second Chance Points per Game
Steals
Steals Per Game
Technical Fouls
Three Points Attempted
Three Points Attempted Per Game
Three Points Made
Three Points Made Per Game
Three Points Percentage
Turnovers
Turnovers Per Game
Two Points Attempted
Two Points Attempted Per Game
Two Points Made
Two Points Made Per Game
Two Points Percentage
Player Seasonal Statistics Data Points: Assists
Assists Per Game
Assists to Turnover Ratio
Blocked Attempts
Blocked Attempts Per Game
Blocked Shots
Blocked Shots Per Game
Defensive Rebounds
Defensive Rebounds Per Game
Ejections
Field Goals Attempted
Field Goals Attempted Per Game
Field Goals Made
Field Goals Made Per Game
Field Goals Percentage
Flagrant Fouls
Flagrant Fouls Per Game 		Foul Outs
Free Throws Attempted
Free Throws Attempted Per Game
Free Throws Made
Free Throws Made Per Game
Free Throws Percentage
Games Played
Games Started
Minutes Played
Minutes Played Per Game
Offensive Rebounds
Offensive Rebounds Per Game
Personal Fouls
Personal Fouls Per Game
Points
Points Per Game
Rebounds 		Rebounds Per Game
Steals
Steals Per Game
Technical Fouls
Three Points Attempted
Three Points Attempted Per Game
Three Points Made
Three Points Made Per Game
Three Points Percentage
Turnovers
Turnovers Per Game
Two Points Attempted
Two Points Attempted Per Game
Two Points Made
Two Points Made Per Game
Two Points Percentage
Team Seasonal Statistics Data Points: Assists
Assists Per Game
Assists To Turnover Ratio
Blocked Attempts
Blocked Attempts Per Game
Blocked Shots
Blocked Shots Per Game
Defensive Rebounds
Defensive Rebounds Per Game
Ejections
Fast Break Points
Fast Break Points Per Game
Field Goals Attempted
Field Goals Attempted Per Game
Field Goals Made
Field Goals Made Per Game
Field Goals Percentage
Flagrant Fouls
Flagrant Fouls Per Game 		Foul Outs
Free Throws Attempted
Free Throws Attempted Per Game
Free Throws Made
Free Throws Made Per Game
Free Throws Percentage
Games Played
Minutes Played
Minutes Played Per Game
Offensive Rebounds
Offensive Rebounds Per Game
Personal Fouls
Personal Fouls Per Game
Points
Points in the Paint
Points in the Paint Per Game
Points off Turnovers
Points off Turnovers Per Game
Points Per Game 		Rebounds
Rebounds Per Game
Second Chance Points
Second Chance Points per Game
Steals
Steals Per Game
Technical Fouls
Three Points Attempted
Three Points Attempted Per Game
Three Points Made
Three Points Made Per Game
Three Points Percentage
Turnovers
Turnovers Per Game
Two Points Attempted
Two Points Attempted Per Game
Two Points Made
Two Points Made Per Game
Two Points Percentage
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/tournaments/dc5c5f27-9860-4ce8-8549-d0e714811dd0/teams/7f4f0451-6b78-4082-9503-ce851e549b0c/statistics.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", "/ncaawb/trial/v8/en/tournaments/dc5c5f27-9860-4ce8-8549-d0e714811dd0/teams/7f4f0451-6b78-4082-9503-ce851e549b0c/statistics.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/ncaawb/trial/v8/en/tournaments/dc5c5f27-9860-4ce8-8549-d0e714811dd0/teams/7f4f0451-6b78-4082-9503-ce851e549b0c/statistics.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Tournament Statistics feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/tournaments/`{tournament_id}`/teams/`{team_id}`/statistics.`{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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `tournament_id` | ID for a given tournament. | | `team_id` | ID for a given team. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Tournament Summary (Seeded Tournaments Only) Tournament information including location, status, start date, end date, set up, and participants.
Update Frequency: As Necessary
Content Type: XML or JSON
Team Information Data Points: Id
Market 		Name Seed
Tournament Data Points: Bracket Id
Bracket Location
Bracket Name
Bracket Rank 		End Date
Start Date
Status 		Id
Location
Name
```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/ncaawb/trial/v8/en/tournaments/9af41eec-ebc0-4ac2-bd6c-53625c6b4522/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", "/ncaawb/trial/v8/en/tournaments/9af41eec-ebc0-4ac2-bd6c-53625c6b4522/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/ncaawb/trial/v8/en/tournaments/9af41eec-ebc0-4ac2-bd6c-53625c6b4522/summary.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. Access the Tournament Summary feed by replacing the parameters in the following URL: https://api.sportradar.com/ncaawb/`{access_level}`/`{version}`/`{language_code}`/tournaments/`{tournament_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: v8). | | `language_code` | 2 letter code for supported language: en (English). | | `tournament_id` | ID for a given tournament. | | `format` | xml or json. | | `your_api_key` | Your API key. | Return to top ## Frequently Asked Questions

Q: What format are date fields presented in?

A: When we present date only values we present these in the ISO 8601 standard format.
ex: 2013-04-03
We use these for attributes that have date and no time (such as birthdate). For more information: https://en.wikipedia.org/wiki/ISO_8601

Q: What format are the date/time fields presented in?

A: All of our Date/Time attributes are in UTC, presented in the ISO 8601 standard format.
ex: 2013-04-03T18:15:00+00:00
For more information: https://en.wikipedia.org/wiki/ISO_8601

Q: What game statuses can I expect to see in the feeds and what are their definitions?

A: Here is a list of the valid game statuses you can expect to see, and their definitions.

  • scheduled - The game is scheduled to occur.
  • inprogress – The game is in progress.
  • halftime - The game is currently at halftime.
  • complete – The game is over, but stat validation is not complete.
  • closed – The game is over and the stats have been validated.
  • cancelled – The game has been cancelled. No makeup game will be played as a result.
  • created - The game has been created and we have begun logging information.
  • delayed – The start of the game is currently delayed or the game has gone from in progress to delayed for some reason.
  • postponed – The game has been postponed, to be made up at another day and time. Once the makeup game is announced, a new game and ID will be created and scheduled on the announced makeup date. You should request the scheduled feed(s) regularly to identify the re-scheduled makeup game(s).
  • unnecessary – The series game was scheduled to occur, but will not take place due to one team clinching the series early.
  • time-tbd – The game has been scheduled, but a time has yet to be announced.
  • if-necessary – The game will be scheduled if it is required.

Q: What are the player experience values I can expect to see in the feeds?

A: Here is a list of the valid player experience values and their definitions:

  • FR – Freshman
  • SO – Sophomore
  • JR – Junior
  • SR – Senior
  • GR – Graduate Student

Q: What player positions can I expect to see in the feeds?

A: Here is a list of the valid player positions you can expect to see.

  • NA
  • C
  • C-F
  • F
  • F-C
  • F-G
  • G
  • G-F

Q: What player primary positions can I expect to see in the feeds?

A: Here is a list of the valid player primary positions you can expect to see.

  • NA
  • C
  • PF
  • PG
  • SF
  • SG

Q: What player statuses can I expect to see in the feeds?

A: Here is a list of the valid player statuses you can expect to see.

  • ACT – The player is on the team’s active roster
  • NWT – The player is no longer with the team
  • SUS – The player is suspended

Q: What are the valid season types?

A: Here is a list of the valid season types and their definition:

  • reg – Regular season
  • ct – Conference tournaments
  • pst – Post-season

Q: What post-season national tournaments do you cover?

A: We will be covering the NCAA National Tournament.

Q: What is the scale of the X Y coordinates?

A: The court we use is 1128 by 600. The scale is in inches. Here is a layout of the court:

0 X 1128
Y
600

Q: Why does the team_basket attribution in the play-by-play feed not match the basket orientation (left vs. right) in the broadcast or game tracking that I'm viewing?

A: Our team_basket attribution is set to match the orientation of the local television broadcast, which is on the opposite side of the scorer's table. The team_basket attribution may not match the orientation used by the particular broadcast or game tracker that you are viewing.

If you want to provide a perspective from the scorer's table, you will have to map the coordinates so that the coordinates attributed to left side of the court are attributed to the right side of the court on your end (and vice versa).

Q: What are the valid events types tracked in the play by play feed?

A: Here is a list of the valid event types you can expect to see.

  • clearpathfoul
  • ejection
  • endperiod
  • flagrantone
  • flagranttwo
  • freethrowmade
  • freethrowmiss
  • jumpball
  • offensivefoul
  • officialtimeout
  • openinbound
  • opentip
  • personalfoul
  • possession
  • rebound
  • shootingfoul
  • teamtimeout
  • technicalfoul
  • threepointmade
  • threepointmiss
  • turnover
  • tvtimeout
  • twopointmade
  • twopointmiss

Q: When we will the NCAA Tournament schedule be available?

A: The initial release of the NCAA Tournament schedule will be released within 2 hours of the completion of the Selection Sunday telecast.

Q: When are scores added to the schedule feeds?

A: Final scores are added to the schedule feeds when the game status changes to completed.

Q: How are home/away team designations determined for neutral-site games, and are those designations consistent across Sportradar products?

A: In the NCAAWB API, there are no "official" home/away designations for neutral-site games. For neutral-site games, we set the neutral-site value to "true".

As a result, this game will count towards Gonzaga's and Eastern Michigan's neutral-site record and not their respective home and away records. In the NCAAWB API, we use the home/away team designations present when we initially ingest the schedules. We will not change the home/away designations after the schedule is initially published. This does not apply to games that have been changed from a neutral-site game to a traditional home/away game, we may change home/away team designations in these cases. Since other Sportradar products may publish schedules at different times and use different fixture management workflows, they may (for neutral-site games) display different home/away team designations.

Q: What shot type descriptions can I expect to see in the feeds?

A: Here is a list of the valid shot types with the descriptions you can expect to see for each shot type.

Jump Shot (This is the only shot type for 3-point attempts)

  • bank
  • driving
  • driving bank
  • driving floating
  • driving floating bank
  • turnaround
  • turnaround bank
  • turnaround fadeaway
  • turnaround fadeaway bank
  • floating
  • fadeaway
  • fadeaway bank
  • stepback
  • stepback bank
  • pullup
  • pullup bank
  • running
  • running pullup

Layup

  • alley-oop
  • cutting
  • cutting finger roll
  • driving
  • driving reverse
  • driving finger roll
  • finger roll
  • putback
  • reverse
  • running
  • running reverse
  • running finger roll
  • running alley-oop
  • tip

Dunk

  • alley-oop
  • tip
  • driving
  • driving reverse
  • putback
  • running
  • reverse
  • running reverse
  • running alley-oop
  • cutting

Tip Shot

Hook

  • bank
  • driving
  • driving bank
  • turnaround
  • turnaround bank
Return to top

version 8 as of 4 weeks ago by Paul Sutton

Docs Navigation