Tennis v3

Frequently Asked Questions
API API Version
Tennis v3
Note: Authentication is required for all API calls.
## Tennis v3 Failover Information

If our scout feed goes down or becomes unavailable, Sportradar takes over Live Data Entry (LDE) to provide a failover.

In case of a failover, we follow one of the following scenarios:

  1. Continue point-by-point coverage – but lose service outcomes. During the failover we cannot provide data related to service outcome. The following data will be unavailable: aces, double faults, service faults, and successful service outcome. Those statistics will be verified and updated post-match.
  2. If point-by-point coverage is not possible – we will update game-by-game, post-match. During the failover we cannot provide point-by-point coverage and service outcomes. The following data will be unavailable: aces, double faults, service faults, and successful service outcome. Missing point-by-point coverage and statistics will be verified and updated post-match. Tie-break score will not be displayed. Game-by-game coverage will continue as each match ends.
## Competition Info Returns key information for a given competition ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/competitions/sr:competition:3101/info.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/competitions/sr:competition:3101/info.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/tennis/trial/v3/en/competitions/sr:competition:3101/info.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Competition Info. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/competitions/`{competition_id}`/info.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `competition_id` | Id of the competition. | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Competition Seasons Returns a list of seasons for a given competition ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/competitions/sr:competition:620/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.us") conn.request("GET", "/tennis/trial/v3/en/competitions/sr:competition:620/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/tennis/trial/v3/en/competitions/sr:competition:620/seasons.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Competition Seasons. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/competitions/`{competition_id}`/seasons.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `competition_id` | Id of the competition. | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Competitions Displays all competitions. ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/competitions.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/competitions.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/tennis/trial/v3/en/competitions.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Competitions information. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/competitions.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Competitor Profile Provides stats and information pertaining to a competitor ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/competitors/sr:competitor:89320/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.us") conn.request("GET", "/tennis/trial/v3/en/competitors/sr:competitor:89320/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/tennis/trial/v3/en/competitors/sr:competitor:89320/profile.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Competitor Profile. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/competitors/`{competitor_id}`/profile.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `competitor_id` | Id of the competitor. | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Competitor Summaries Returns sport event information for a given competitor, including all previous and upcoming matches and statistics. ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/competitors/sr:competitor:14882/summaries.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/competitors/sr:competitor:14882/summaries.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/tennis/trial/v3/en/competitors/sr:competitor:14882/summaries.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Competitor Summaries. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/competitors/`{competitor_id}`/summaries.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `competitor_id` | Id of the competitor. | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Competitor vs Competitor Provides past and upcoming match details between two competitors given two competitor IDs. ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/competitors/sr:competitor:122366/versus/sr:competitor:23581/summaries.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/competitors/sr:competitor:122366/versus/sr:competitor:23581/summaries.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/tennis/trial/v3/en/competitors/sr:competitor:122366/versus/sr:competitor:23581/summaries.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Competitor vs Competitor information for two competitors. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/competitors/`{competitor_id}`/versus/`{competitor_id2}`/summaries.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `competitor_id` | Id of the competitor. | | `competitor_id2` | Id of the competitor. | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Complexes Lists all complexes and venues available in the API ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/complexes.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/complexes.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/tennis/trial/v3/en/complexes.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves Complexes. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/complexes.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Daily Summaries Returns a list of summaries for all competitions given a specific date: yyyy-mm-dd. ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/schedules/2018-01-08/summaries.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/schedules/2018-01-08/summaries.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/tennis/trial/v3/en/schedules/2018-01-08/summaries.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Daily Summaries. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/schedules/`{year}`-`{month}`-`{day}`/summaries.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `year` | Year in 4 digit format (YYYY). | | `month` | Month in 2 digit format (MM). | | `day` | Day of the month in 2 digit format (DD). | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Doubles Race Rankings Rankings for the ATP/WTA finals ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/double_competitors_race_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.us") conn.request("GET", "/tennis/trial/v3/en/double_competitors_race_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/tennis/trial/v3/en/double_competitors_race_rankings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Doubles Race Rankings. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/double_competitors_race_rankings.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Doubles Rankings Rankings in ascending order for doubles. ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/double_competitors_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.us") conn.request("GET", "/tennis/trial/v3/en/double_competitors_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/tennis/trial/v3/en/double_competitors_rankings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Doubles Rankings. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/double_competitors_rankings.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Live Summaries Returns information for currently live matches including live updates and statistics ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/schedules/live/summaries.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/schedules/live/summaries.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/tennis/trial/v3/en/schedules/live/summaries.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Live Summaries. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/schedules/live/summaries.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Live Timelines Returns timeline information for currently live matches including live updates ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/schedules/live/timelines.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/schedules/live/timelines.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/tennis/trial/v3/en/schedules/live/timelines.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Live Timelines. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/schedules/live/timelines.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Live Timelines Delta Returns a 10 second delta of timeline information for currently live matches including live updates ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/schedules/live/timelines_delta.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/schedules/live/timelines_delta.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/tennis/trial/v3/en/schedules/live/timelines_delta.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Live Timelines Delta. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/schedules/live/timelines_delta.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Race Rankings Returns a list in ascending order for the race to the ATP/WTA finals ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/race_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.us") conn.request("GET", "/tennis/trial/v3/en/race_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/tennis/trial/v3/en/race_rankings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Race Rankings. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/race_rankings.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Rankings Returns a list in ascending order of ATP/WTA world rankings ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/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.us") conn.request("GET", "/tennis/trial/v3/en/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/tennis/trial/v3/en/rankings.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Rankings. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/rankings.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Season Info Displays information about a season and lists competitors with respective IDs. ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/seasons/sr:season:74057/info.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/seasons/sr:season:74057/info.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/tennis/trial/v3/en/seasons/sr:season:74057/info.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves Season Info. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/info.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `season_id` | Id of a given season | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Season Summaries Returns the sport event summaries for a given season ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/seasons/sr:season:74057/summaries.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/seasons/sr:season:74057/summaries.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/tennis/trial/v3/en/seasons/sr:season:74057/summaries.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves Season Summaries. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/summaries.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `season_id` | Id of a given season | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Seasonal Competitors Displays a listing of all competitors with respective IDs that compete in a given season. ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/seasons/sr:season:74057/competitors.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/seasons/sr:season:74057/competitors.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/tennis/trial/v3/en/seasons/sr:season:74057/competitors.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves Seasonal Competitors. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/competitors.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `season_id` | Id of a given season | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Seasonal Probabilities Provides sport event probabilities for various match markets and outcomes. ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/seasons/sr:season:61767/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.us") conn.request("GET", "/tennis/trial/v3/en/seasons/sr:season:61767/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/tennis/trial/v3/en/seasons/sr:season:61767/probabilities.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves Seasonal Probabilities. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/seasons/`{season_id}`/probabilities.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `season_id` | Id of a given season | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Seasons Displays a listing of all available seasons. ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/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.us") conn.request("GET", "/tennis/trial/v3/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/tennis/trial/v3/en/seasons.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves Seasons. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/seasons.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | | `your_api_key` | Your API key. | ## Sport Event Summary Returns information for a match including live updates and statistics ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/sport_events/sr:sport_event:24216873/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.us") conn.request("GET", "/tennis/trial/v3/en/sport_events/sr:sport_event:24216873/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/tennis/trial/v3/en/sport_events/sr:sport_event:24216873/summary.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Sport Event Summary. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/matches/`{sport_event_id}`/summary.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `sport_event_id` | id of the sport event. | | `format` | xml or json. | ## Sport Event Timeline Returns information for a given sport event ID including a timeline of events, (point-by-point or Game-by-Game depending on the coverage) and some basic stats ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/sport_events/sr:sport_event:24025503/timeline.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/sport_events/sr:sport_event:24025503/timeline.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/tennis/trial/v3/en/sport_events/sr:sport_event:24025503/timeline.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves the Sport Event Timeline. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/sport_event/`{sport_event_id}`/timeline.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `sport_event_id` | id of the sport event. | | `format` | xml or json. | ## Sport Events Removed Returns a list of all sport events that have been removed from coverage ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/sport_events/removed.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/sport_events/removed.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/tennis/trial/v3/en/sport_events/removed.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves a list of Removed Matches. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/sport_events/removed.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | ## Sport Events Updated Returns a list of all sport events that have been updated ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("https://api.sportradar.com/tennis/trial/v3/en/sport_events/updated.xml?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/en/sport_events/updated.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/tennis/trial/v3/en/sport_events/updated.xml?api_key={your_api_key}" ``` > The above command returns xml structured like this. This endpoint retrieves a list of Updated sport events. https://api.sportradar.com/tennis/`{access_level}`/`{version}`/`{language_code}`/sport_events/updated.`{format}`?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `language_code` | English (en), Italian (it), German (de), French (fr), Swedish (se), Spanish (es), Russian (ru), Chinese simplified (zh), Chinese traditional (zht), Japanese (ja), Hindi (hi), Turkish (tr), Norwegian (no), Danish (da), Dutch (nl), Portuguese (pt), Finnish (fi), Thai (th), Hungarian (hu), Serbian (sr), Indonesian (id), Korean (ko), or Serbian Latin (srl). | | `format` | xml or json. | ## Push Feeds >To best utilize Push feeds, we have included code samples in Ruby and Java which provides an example of a way you can consume the feeds. Using these samples will output the feeds content to STDOUT.
For Java, we have also provided a Stream Client to assist your integration.

Note: In the provided Java sample, replace "URL GOES HERE" with the desired Push feed URL. ```ruby require 'httpclient' module Sportradar module HTTP module Stream class Client attr_reader :url, :logger def initialize(url, publisher, logger) @url = url @logger = logger @publisher = publisher @client = ::HTTPClient.new(:agent_name => 'SportsData/1.0') end def start @thread ||= Thread.new do logger.debug "Starting loop" @client.get_content(url, :follow_redirect => true) do |chunk| @publisher.publish(::JSON.parse(chunk)) if @publisher end logger.debug "finished loop" end end def stop @thread.terminate if @thread end end end end end ``` ```java package com.sportradar.http.stream.client; import org.junit.After; import org.junit.Before; import org.junit.Test; public class StreamClientTest { private StreamClient client; private static String SERVICE_URL = ""; @Before public void setup() { client = new StreamClient(); } @After public void cleanup() { client.terminate(); } @Test public void testStream() throws Exception { Handler handler = new ConsoleHandler(); client.stream(SERVICE_URL, handler); System.out.println("Connecting...."); Thread.sleep(1 * 60 * 1000); System.out.println("Disconnecting...."); } } ``` Some of our APIs include Push feeds that allow you to get updates as soon as they are available. Push API feeds automatically send XML and JSON payload to you via a push service, and can dramatically reduce the number of calls you need to make to our RESTful API feeds. The structure of the Push feeds are similar to the structure of the corresponding RESTful API feed (i.e. Push Events, and Push Statistics). The push service ensures reliable and efficient delivery of the most up to date information. Our Push services are based on a HTTP publish/subscribe model. When making a call to the Push APIs, you "subscribe" to various data feeds provided by our service; whenever new content is available on one of those feeds, the server pushes that information out to your client. When no new information is available on the feed, a heartbeat message is sent every 5 seconds to keep the connection active. If you want to filter the results of the feeds, there are several optional query string parameters that can be applied to the API call. If left unfiltered, than all data for the feed is displayed (i.e. all games, events, or statistics). For your applications to accept data from our Push feeds, ensure that your application can: * Can follow a HTTP redirect or use the location provided in the feeds header within one minute of your initial request. * Can accept HTTP data transfer encoded as chunked. Our Push service does not provide a "stateful session", there is no memory of what data has been sent previously. If you are disconnected from the Push session, you can use the RESTful API to catch up or recover from the disconnection. Syntax for using our Push feeds and examples of the JSON payloads can be found below. ## Push - Events Returns detailed, real-time information on every game event ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("http://api.sportradar.us/tennis/trial/v3/stream/events/subscribe?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/stream/events/subscribe?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -L GET 'api.sportradar.us/tennis/trial/v3/stream/events/subscribe?api_key={your_api_key}' ``` >The above command returns json like this. This endpoint retrieves the Events information via Push. http://api.sportradar.us/tennis/`{access_level}`/`{version}`/stream/events/subscribe?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `your_api_key` | Your API key. | ### Optional Query String Parameters >Example including optional query string parameters: ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("http://api.sportradar.us/tennis/trial/v3/stream/events/subscribe?api_key={your_api_key}&format=json&competition_id=sr:competition:16126") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/stream/events/subscribe?api_key={your_api_key}&format=json&competition_id=sr:competition:16126") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -L GET 'api.sportradar.us/tennis/trial/v3/stream/events/subscribe?api_key={your_api_key}&format=json&competition_id=sr:competition:16126' ``` In addition to the URL parameters listed above, you can filter the Events information with one or more of the following optional query string parameters.
Note: Optional query string parameters must be added after your API key with an ampersand (&). If you are filtering for more than one result, separate the results with a comma (,) and no spaces.
Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `event_id` | Event id expressed as: {event_id}.
Example: event_id=point | | `format` | Format expressed as: {format}.
Example: format=json | | `sport_event_id` | Sport Event Id expressed as: {sport_event_id}.
Example: sport_event_id=sr:match:14586844 | | `competition_id` | Tournament Id expressed as: {competition_id}.
Example: competition_id=sr:competition:16126 | ## Push - Statistics Returns detailed game stats at the doubles team or player level ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("http://api.sportradar.us/tennis/trial/v3/stream/statistics/subscribe?api_key={your_api_key}") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/stream/statistics/subscribe?api_key={your_api_key}") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -L GET 'api.sportradar.us/tennis/trial/v3/stream/statistics/subscribe?api_key={your_api_key}' ``` > The above command returns json like this. This endpoint retrieves the Statistics information via Push. http://api.sportradar.us/tennis/`{access_level}`/`{version}`/stream/statistics/subscribe?api_key=`{your_api_key}` Replace placeholders with the following query parameters: | 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: v3). | | `your_api_key` | Your API key. | ### Optional Query String Parameters >Example including optional query string parameters: ```ruby require 'uri' require 'net/http' require 'openssl' url = URI("http://api.sportradar.us/tennis/trial/v3/stream/statistics/subscribe?api_key={your_api_key}&format=json&competition_id=sr:competition:16126") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Get.new(url) response = http.request(request) puts response.read_body ``` ```python import http.client conn = http.client.HTTPSConnection("api.sportradar.us") conn.request("GET", "/tennis/trial/v3/stream/statistics/subscribe?api_key={your_api_key}&format=json&competition_id=sr:competition:16126") res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```shell curl -L GET 'api.sportradar.us/tennis/trial/v3/stream/statistics/subscribe?api_key={your_api_key}&format=json&competition_id=sr:competition:16126' ``` In addition to the URL parameters listed above, you can filter the Statistics information with one or more of the following optional query string parameters.
Note: Optional query string parameters must be added after your API key with an ampersand (&). If you are filtering for more than one result, separate the results with a comma (,) and no spaces.
Replace placeholders with the following query parameters: | Parameter | Description | | --------- | ----------- | | `event_id` | Event id expressed as: {event_id}.
Example: event_id=point | | `format` | Format expressed as: {format}.
Example: format=json | | `sport_event_id` | Sport Event Id expressed as: {sport_event_id}.
Example: sport_event_id=sr:match:14586844 | | `competition_id` | Tournament Id expressed as: {competition_id}.
Example: competition_id=sr:competition:16126 | ## 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 competitions are covered for Tennis?

A: We cover the following competitions with the following coverage:

Tier 1: Grand Slams
Point-by-point live coverage for men’s, women’s, singles doubles, mixed doubles
Standard Match statistics live
Detailed service outcomes
Extended match statistics for quarter finals onwards for men’s and women’s singles (winners, errors, unforced errors broken down by a few shot types)
Post-match corrections
Court information

Tier 2: ATP1000, ATP Finals, ATP 500, ATP Cup WTA Finals, WTA 1000, WTA 500, WTA Elite Trophy, WTA Premier Fed Cup (World Group), Davis Cup (World Group)
Point-by-point live coverage for men’s, women’s, singles doubles, mixed doubles
Standard match statistics live
Detailed service outcomes
Post-match corrections
Court information

Tier 3: ITF
Point-by-point from Round 1
Standard Match Stats, (no detailed service outcomes)
No post-match corrections
No guaranteed court information

Tier 4: ATP250, WTA Int, WTA 250, WTA125k
Standard Match Stats from semi finals
Point-by-Point from Semi Finals
Post-match corrections from semi-finals
No guaranteed court information

Tier 5: Challenger, Fed Cup (non-World Group), Davis Cup (Non-world Group)
No Point by Point
Game by Game Score or results only post-match
No post-match corrections
No guaranteed court information

General:
Schedules
Results
Player profiles (vital statistics only – not biographies)
Seasonal match outcome statistics for players
Rankings
Race Rankings
Pre-match probabilities
Basic tournament information

Q: Which statistics are considered extended match stats and which are standard stats?

A: Here are the extended match stats:

  • backhand_errors
  • backhand_unforced_errors
  • backhand_winners
  • volley_errors
  • volley_unforced_errors
  • volley_winners
  • forehand_errors
  • forehand_unforced_errors
  • forehand_winners
  • groundstroke_errors
  • groundstroke_unforced_errors
  • groundstroke_winners
  • lob_unforced_errors
  • lob_winners
  • overhead_errors
  • overhead_stroke_errors
  • overhead_winners
  • return_errors
  • return_unforced_errors
  • return_winners
  • service_unforced_errors
  • service_games_won
  • service_points_lost
  • service_points_won
  • tiebreaks_won
  • drop_shot_unforced_errors
  • drop_shot_winners

Q: When are standard match stats available?

A: Standard match stats are available whenever live point-by-point coverage is true.

Q: What are the standard match statistics?

A: Here are the available standard match stats:

  • aces
  • double_faults
  • games_won
  • max_games_in_a_row
  • max_points_in_a_row
  • points_won
  • breakpoints_won
  • total_breakpoints
  • first_serve_points_won
  • first_serve_successful
  • second_serve_points_won
  • second_serve_successful
  • aces
  • double_faults
  • second_serve_successful
  • second_serve_points_won

Q: What are the definitions for the various statistics?

A: Here are the definitions for the various statistics:

General definitions:

  • Racket arm: The arm with which the player serves and holds the racket. It is used to define if a player is right-handed or left-handed.
  • Stroke/Shot: The act of striking the ball with the racket.
  • Serve: Short for Service.
  • Server: The player who serves.
  • Returner/Receiver: The player who receives the serve.
  • Return: A shot used to hit back the serve.
  • Forehand: A shot hit from the racket-arm side of the body. The stroke used to return balls hit to the right side of a right-handed player and to the left side of a left-handed player. Forehands are commonly hit one-handed.
  • Backhand: A stroke in which the ball is struck on the opposite side of the body to the racket arm. The stroke is used to return balls hit to the left side of a right-handed player and to the right side of a left-handed player. Backhands are hit either one-handed or two-handed.
  • Groundstroke: A stroke made after the ball has bounced. The standard shot in tennis. Can be either forehand or backhand.
  • Volley: During play, a shot where the ball is hit before it bounces. Can be either forehand or backhand.
  • Overhead: During play, a stroke made with the racket above the head in a motion similar to that of an overhand serve.
  • Drop Shot: A softly hit ball (usually with backspin) that drops near the net after crossing it. Is hit either as a groundstroke or a volley and can be either forehand or backhand.
  • Lob: A stroke that lifts the ball high in the air, usually over the head of the opponent at the net. Is hit either as a groundstroke or a volley and can be either forehand or backhand.

Sportradar Definition – Winners

  • Winner: A winner is any shot that is hit successfully into the opposite side of the court that the opponent can’t manage to get a shot at. It can either be a clean hit without any racket touch or where the opponent only manages to slightly touch the ball (racket clip). Important is that the opponent cannot manage to hit a proper shot. All the below specifications count as Winners in Statistics.
  • Ace: A ball that is served without an opponent (receiver) touching the ball with the racket (usually due to well executed serve)
  • Return winner: A direct winner hit when returning serve. Can be either forehand or backhand.
  • Groundstroke winner: A winner hit as a groundstroke. Can be either forehand or backhand.
  • Volley winner: A winner hit as a volley. Can be either forehand or backhand.
  • Overhead winner: A winner hit as an overhead shot.
  • Drop shot winner: A winner hit as a drop shot. Has to be either groundstroke or volley and can be either forehand or backhand.
  • Lob winner: A winner hit as a lob. Has to be either groundstroke or volley and can be either forehand or backhand.

Sportradar Definition – Forced errors

  • Forced error: An unsuccessful shot caused by an opponent`s good play. Primarily defined when the player who made the error is under time pressure or is on the move/on the defense during the shot execution. If one of those factors is true, then the player was forced into a difficult situation by a good shot and thus made a forced error. All the below specifications count as Forced Errors in Statistics.
  • Return forced error: A forced error caused by an opponent`s serve, player gets racket to the ball but is unable to put it in play (incl. Racket Clip).
  • Groundstroke forced error: A forced error while trying to hit a groundstroke. Can be either forehand or backhand.
  • Volley forced error: A forced error while trying to hit a volley. Can be either forehand or backhand.
  • Overhead forced error: A forced error while trying to hit an overhead shot.

Sportradar Definition – Unforced errors

  • Unforced error: An unsuccessful shot due to an error without being forced under pressure by the opponent. All the below specifications count as Unforced Errors in Statistics.
  • Double fault: Two faults served in a row. On a double fault, the server loses the point.
  • Return unforced error: An unforced error while trying to hit a return of serve. Can be either forehand or backhand.
  • Groundstroke unforced error: An unforced error while trying to hit a groundstroke. Can be either forehand or backhand.
  • Volley unforced error: An unforced error while trying to hit a volley. Can be either forehand or backhand.
  • Overhead unforced error: An unforced error while trying to hit an overhead shot.
  • Drop shot unforced error An unforced error while trying to hit a drop shot. Has to be either groundstroke or volley and can be either forehand or backhand.
  • Lob unforced error: An unforced error while trying to hit a lob. Has to be either groundstroke or volley and can be either forehand or backhand.

Q: How do I find all possible values for a given attribute?

A: Refer to the OpenAPI Specification:
https://api.sportradar.com/tennis/production/v3/openapi/swagger/index.html
At the bottom of the page the data models are listed. Within each applicable model there are expandable sections labelled “Enum”.

Q: How long are matches stored in the deleted/updated matches endpoints?

A: The deleted/updated matches endpoints will show sport events removed or updated in the last 2 weeks.

Q: How do venues work for country vs country competitions?

A: In country vs country competitions such as Davis Cup and ATP Cup, venues on the parent matches refer to the complex in which the courts are located. On the child match level venue refers to the court where the match is played. Note that only the finals venue will be linked to complex attribute for the Davis Cup competition.

Q: How does sport event type work in the feeds?

A: The sport_event_type explicitly denotes the match type. Where there are competitions which have "parent matches" and "child matches" where country_format='true', such as Davis Cup and ATP Cup, this attribute will only appear on the "child match" node. The "parent match" sport_event node will have a "type='parent'" attribute and the "competition" node will have a "type='mixed'" attribute. Otherwise, for competitions where "country_format" is not present, the competition will have a type either "singles" or "doubles".

Q: How do I detect when one player has "advantage" in the case where the players both reached "40" or "deuce"?

A: The player who has "advantage" will have a score of "50" in the timeline, for example this is how a game was won by the receiver after a server committed a double_fault when the receiver was at "advantage":

In addition, when in a live situation the "game_state" node will display the following:

Q: Why do some players have height and weight data and others don't? 

A: Only the height and weight of the top 500 ranked players for ATP and WTA are included. There may be some instances where some players outside of the top 500 have these attributes but should not be relied upon.

Q: What are the valid sport_event_status – status values?

A: Status values can change over time, and new values may be added when needed. Here is a list of the currently valid status values and their definitions:

  • not_started – The match is scheduled to be played
  • started – The match has begun
  • postponed – The match has been postponed to a later time
  • match_about_to_start – The match time has expired, awaiting play
  • live – The match is currently in progress
  • closed – The match results have been confirmed.
  • ended – The match is over
  • interrupted - The match began, but coverage has stopped for a short time. Note that match scores may not be updated during this period, the last recorded match score will be displayed instead
  • suspended – The match began, but has been suspended to a later time
  • cancelled – The match has been cancelled and will not be played
  • delayed – The match has been temporarily delayed and will be continued
  • abandoned – The match began, but was then cancelled

Q: What are the valid sport_event_status – match_status values?

A: Match status values can change over time, and new values may be added when needed. Here is a list of the currently valid match status values and their definitions:

  • not_started – The match is scheduled to be played
  • match_about_to_start – The match time has expired, awaiting play
  • start_delayed – The match has been temporarily delayed and will be continued
  • live – The match is currently in progress
  • 1st_set – First set
  • 2nd_set – Second set
  • 3rd_set – Third set
  • 4th_set – Fourth set
  • 5th_set – Fifth set
  • ended – The match is over
  • walkover - The match ended in a walkover
  • interrupted – The match began, but is stopped for a short time
  • suspended – The match began, but has been suspended to a later time
  • cancelled – The match has been cancelled and will not be played
  • postponed – The match has been postponed to a future date
  • delayed – The match has been temporarily delayed and will be continued
  • abandoned – The match began, but was then cancelled
  • retired – The match is incomplete as the result of one player
  • closed – The match results have been confirmed
  • defaulted - The match has ended as a result of one player being disqualified

Q: How do I find out the coverage for a particular match?

A: Find the node called: “coverage – type” which denotes if the match is covered at the sport_event or competition level. When type="sport_event" you will only get sport_event_properties. When type="competition" you will get sport_event_properties and competition_properties. Within coverage, scores states if the match is scored live or post. Extended stats show if we have enhanced stats for the sport event.

Q: Is the statistical data provided in the Tennis API official data?

A: Sportradar collects sports data independently. For some sports Sportradar is the official data provider. In the case of Tennis, we provide official data for ITF tournaments only.

Return to top

Docs Navigation