School

This API is used to provide access to school information such as users, academics, admissions, athletics, content, lists, and general school info.

GET

Athletics schedules

Returns a collection of athletic games for the current school year.
Use the start_date and/or end_date to filter to a specific timeframe.
Returns data for a specific team by setting the team_id using the GET teams endpoint.
Returns both games and practices by setting include_practice to true.
Requires at least one of the following roles in the Education Management system:

  • Athletic Group Manager
  • Team Schedule Manager
  • Schedule Manager
  • Coach
  • Pending Coach

Try it

Request URL

Request parameters

Parameter Required Type Description
start_date string

Filter games/practices after this date
end_date string

Filter games/practices before this date
school_year string

Filter on a specific school year. Defaults to current school year.
include_practice boolean

Set to true to include practices with games. Defaults to false.
team_id integer

Filter games/practices for a specific team. Defaults to all teams.

Request headers

Header Required Type Description
Bb-Api-Subscription-Key Property is required string Subscription key which provides access to this API. Found in your Profile.
Authorization Property is required string OAuth 2.0 access token obtained from Blackbaud OAuth 2.0 Service. Supported grant types: Authorization code.

Response 200 OK

Success

{
  "count": 1,
  "value": [
    {
      "id": 12345,
      "alumni": false,
      "cancelled": false,
      "departure_location": "Front Door",
      "departure_time": "2023-05-30",
      "description": "Some details about the event",
      "directions": "Go out the front door, then take a left",
      "dismissal_time": "2023-05-30",
      "end_time": "2023-05-30",
      "end_time_span": "2023-05-30",
      "title": "Week 7 Scrimmage",
      "faculty": false,
      "game_date": "2021-03-20T00:00:00Z",
      "highlight_id": 1234567,
      "home_or_away": "Home",
      "invitational": false,
      "league": false,
      "location": "Back field #2",
      "map_url": "http://maps.google.com/someplace/somewhere",
      "meet": 90123456,
      "opponents": [
        {
          "id": 9014556,
          "name": "Alabaster Brightwings",
          "score": "77 - 11",
          "win_loss": "Win",
          "opponent_score": "11",
          "team_score": "77"
        }
      ],
      "pickup_time": "2023-05-30",
      "playoff": false,
      "practice": false,
      "published": true,
      "require_dinner": false,
      "require_lunch": false,
      "rescheduled": true,
      "rescheduled_date": "2021-03-20T00:00:00Z",
      "rescheduled_note": "Rescheduled from last month to next month",
      "room_id": 5678901,
      "schedule_type": 1,
      "scrimmage": true,
      "section_id": 8901234,
      "show_details": false,
      "show_directions": true,
      "show_versus": true,
      "start_time": "2023-05-30",
      "team_id": 67890,
      "time": "2023-05-30",
      "tournament": false,
      "uniform_color": "White (away)"
    }
  ]
}
{
  "type": "object",
  "properties": {
    "count": {
      "type": "integer",
      "description": "The number of items in the collection",
      "format": "int32",
      "readOnly": true
    },
    "next_link": {
      "type": "string",
      "description": "For paginated responses, the URI for the next page of results",
      "nullable": true
    },
    "value": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "description": "ID of the schedule item",
            "format": "int32",
            "nullable": true
          },
          "alumni": {
            "type": "boolean",
            "description": "Returns True if the game or practice is marked as alumni",
            "nullable": true
          },
          "cancelled": {
            "type": "boolean",
            "description": "Returns True if the game or practice was cancelled",
            "nullable": true
          },
          "departure_location": {
            "type": "string",
            "description": "Departure location of the game or practice",
            "nullable": true
          },
          "departure_time": {
            "type": "string",
            "description": "The time of departure before the game or practice",
            "nullable": true
          },
          "description": {
            "type": "string",
            "description": "The game or practice description",
            "nullable": true
          },
          "directions": {
            "type": "string",
            "description": "Directions to the game or practice",
            "nullable": true
          },
          "dismissal_time": {
            "type": "string",
            "description": "The time of dismissal before the game or practice",
            "nullable": true
          },
          "end_time": {
            "type": "string",
            "description": "The time a game or practice ends",
            "nullable": true
          },
          "end_time_span": {
            "type": "string",
            "description": "The end time of the game or practice",
            "nullable": true
          },
          "title": {
            "type": "string",
            "description": "The title of the game or practice",
            "nullable": true
          },
          "faculty": {
            "type": "boolean",
            "description": "Returns True if the game or practice is marked as faculty",
            "nullable": true
          },
          "game_date": {
            "type": "string",
            "description": "Date of the game or practice. Uses <a href=\"https://tools.ietf.org/html/rfc3339\" target=\"_blank\">ISO-8601</a> (24H) format: 2003-04-21T10:29:43",
            "format": "date-time",
            "nullable": true
          },
          "highlight_id": {
            "type": "integer",
            "description": "The ID of the game highlight",
            "format": "int32",
            "nullable": true
          },
          "home_or_away": {
            "type": "string",
            "description": "Indicates whether the game is a home game or an away game",
            "nullable": true
          },
          "invitational": {
            "type": "boolean",
            "description": "Returns True if the game or practice is an invitational",
            "nullable": true
          },
          "league": {
            "type": "boolean",
            "description": "Returns True if the game is a league event",
            "nullable": true
          },
          "location": {
            "type": "string",
            "description": "Location of the game or practice",
            "nullable": true
          },
          "map_url": {
            "type": "string",
            "description": "Directions url to the game or practice",
            "nullable": true
          },
          "meet": {
            "type": "integer",
            "description": "Returns 1 if the game is a meet, otherwise returns 0",
            "format": "int32",
            "nullable": true
          },
          "opponents": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "integer",
                  "description": "Opponents team ID",
                  "format": "int32",
                  "nullable": true
                },
                "name": {
                  "type": "string",
                  "description": "Opponents team name",
                  "nullable": true
                },
                "score": {
                  "type": "string",
                  "description": "The final score of the game.",
                  "nullable": true
                },
                "win_loss": {
                  "type": "string",
                  "description": "The outcome of the game.",
                  "nullable": true
                },
                "opponent_score": {
                  "type": "string",
                  "description": "The opponents part of the score",
                  "nullable": true
                },
                "team_score": {
                  "type": "string",
                  "description": "The teams part of the score",
                  "nullable": true
                }
              },
              "additionalProperties": false,
              "description": ""
            },
            "description": "Opponents for the gsame or practice",
            "nullable": true
          },
          "pickup_time": {
            "type": "string",
            "description": "The pickup time after the game or practice",
            "nullable": true
          },
          "playoff": {
            "type": "boolean",
            "description": "Returns True if the game or practice is a playoff",
            "nullable": true
          },
          "practice": {
            "type": "boolean",
            "description": "Returns True if the event is a practice",
            "nullable": true
          },
          "published": {
            "type": "boolean",
            "description": "Returns True if the game schedule is published",
            "nullable": true
          },
          "require_dinner": {
            "type": "boolean",
            "description": "Returns True if the game or practice requires dinner",
            "nullable": true
          },
          "require_lunch": {
            "type": "boolean",
            "description": "Returns True if the game or practice requires a lunch",
            "nullable": true
          },
          "rescheduled": {
            "type": "boolean",
            "description": "Returns True if the game or practice was rescheduled",
            "nullable": true
          },
          "rescheduled_date": {
            "type": "string",
            "description": "The date and time a game or practice has been rescheduled. Uses <a href=\"https://tools.ietf.org/html/rfc3339\" target=\"_blank\">ISO-8601</a> (24H) format: 2003-04-21T10:29:43",
            "format": "date-time",
            "nullable": true
          },
          "rescheduled_note": {
            "type": "string",
            "description": "The resaon a game or practice was rescheduled",
            "nullable": true
          },
          "room_id": {
            "type": "integer",
            "description": "The ID of the room a game or practice is being held",
            "format": "int32",
            "nullable": true
          },
          "schedule_type": {
            "type": "integer",
            "description": "The schedule type",
            "format": "int32",
            "nullable": true
          },
          "scrimmage": {
            "type": "boolean",
            "description": "Returns True if the game or practice is a scrimmage",
            "nullable": true
          },
          "section_id": {
            "type": "integer",
            "description": "The section ID",
            "format": "int32",
            "nullable": true
          },
          "show_details": {
            "type": "boolean",
            "description": "Returns True if details for a game or practice are avalible",
            "nullable": true
          },
          "show_directions": {
            "type": "boolean",
            "description": "Returns true if the game or practice should display \"the directions on the school website",
            "nullable": true
          },
          "show_versus": {
            "type": "boolean",
            "description": "Returns true if the game or practice should display \"vs\" on the school website",
            "nullable": true
          },
          "start_time": {
            "type": "string",
            "description": "The start time of the game or practice",
            "nullable": true
          },
          "team_id": {
            "type": "integer",
            "description": "ID of the team",
            "format": "int32"
          },
          "time": {
            "type": "string",
            "description": "Time of the game or practice",
            "nullable": true
          },
          "tournament": {
            "type": "boolean",
            "description": "Returns True if the game or practice is a tournament",
            "nullable": true
          },
          "uniform_color": {
            "type": "string",
            "description": "The color of the uniforms for the game or practice",
            "nullable": true
          }
        },
        "additionalProperties": false,
        "description": ""
      },
      "description": "The set of items included in the response. This may be a subset of the items in the collection",
      "nullable": true
    }
  },
  "additionalProperties": false,
  "description": "A Collection"
}

Code samples

@ECHO OFF

curl -v -X GET "https://api.sky.blackbaud.com/school/v1/athletics/schedules?start_date={string}&end_date={string}&school_year={string}&include_practice=false&team_id=0"
-H "Bb-Api-Subscription-Key: {subscription key}"
-H "Authorization: Bearer {access token}"
--data-ascii "{body}"

using System;
using System.Net.Http.Headers;
using System.Text;
using System.Net.Http;
using System.Web;

namespace CSHttpClientSample
{
    static class Program
    {
        static void Main()
        {
            MakeRequest();
            Console.WriteLine("Hit ENTER to exit...");
            Console.ReadLine();
        }

        static async void MakeRequest()
        {
            var client = new HttpClient();
            var queryString = HttpUtility.ParseQueryString(string.Empty);

            // Request headers
            client.DefaultRequestHeaders.Add("Bb-Api-Subscription-Key", "{subscription key}");
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {access token}");

            // Request parameters
            queryString["start_date"] = "{string}";
            queryString["end_date"] = "{string}";
            queryString["school_year"] = "{string}";
            queryString["include_practice"] = "false";
            queryString["team_id"] = "0";
            var uri = "https://api.sky.blackbaud.com/school/v1/athletics/schedules?" + queryString;

            var response = await client.GetAsync(uri);
        }
    }
}
// // This sample uses the Apache HTTP client from HTTP Components (http://hc.apache.org/httpcomponents-client-ga/)
import java.net.URI;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class JavaSample 
{
    public static void main(String[] args) 
    {
        HttpClient httpclient = HttpClients.createDefault();

        try
        {
            URIBuilder builder = new URIBuilder("https://api.sky.blackbaud.com/school/v1/athletics/schedules");

            builder.setParameter("start_date", "{string}");
            builder.setParameter("end_date", "{string}");
            builder.setParameter("school_year", "{string}");
            builder.setParameter("include_practice", "false");
            builder.setParameter("team_id", "0");

            URI uri = builder.build();
            HttpGet request = new HttpGet(uri);
            request.setHeader("Bb-Api-Subscription-Key", "{subscription key}");
            request.setHeader("Authorization", "Bearer {access token}");

            // Request body
            StringEntity reqEntity = new StringEntity("{body}");
            request.setEntity(reqEntity);

            HttpResponse response = httpclient.execute(request);
            HttpEntity entity = response.getEntity();

            if (entity != null) 
            {
                System.out.println(EntityUtils.toString(entity)); 
            }
        }
        catch (Exception e)
        {
            System.out.println(e.getMessage());
        }
    }
}


<!DOCTYPE html>
<html>
<head>
    <title>JSSample</title>
    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.9.0/jquery.min.js"></script>
</head>
<body>

<script type="text/javascript">
    $(function() {
        var params = {
            // Request parameters
            "start_date": "{string}",
            "end_date": "{string}",
            "school_year": "{string}",
            "include_practice": "false",
            "team_id": "0",
        };

        $.ajax({
            url: "https://api.sky.blackbaud.com/school/v1/athletics/schedules?" + $.param(params),
            beforeSend: function(xhrObj){
                // Request headers
                xhrObj.setRequestHeader("Bb-Api-Subscription-Key","{subscription key}");
                xhrObj.setRequestHeader("Authorization","Bearer {access token}");
            },
            type: "GET",
            // Request body
            data: "{body}",
        })
        .done(function(data) {
            alert("success");
        })
        .fail(function() {
            alert("error");
        });
    });
</script>
</body>
</html>

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[])
{
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

    NSString* path = @"https://api.sky.blackbaud.com/school/v1/athletics/schedules";
    NSArray* array = @[
                         // Request parameters
                         @"entities=true",
                         @"start_date={string}",
                         @"end_date={string}",
                         @"school_year={string}",
                         @"include_practice=false",
                         @"team_id=0",
                      ];

    NSString* string = [array componentsJoinedByString:@"&"];
    path = [path stringByAppendingFormat:@"?%@", string];

    NSLog(@"%@", path);

    NSMutableURLRequest* _request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:path]];
    [_request setHTTPMethod:@"GET"];
    // Request headers
    [_request setValue:@"{subscription key}" forHTTPHeaderField:@"Bb-Api-Subscription-Key"];
    [_request setValue:@"Bearer {access token}" forHTTPHeaderField:@"Authorization"];
    // Request body
    [_request setHTTPBody:[@"{body}" dataUsingEncoding:NSUTF8StringEncoding]];

    NSURLResponse *response = nil;
    NSError *error = nil;
    NSData* _connectionData = [NSURLConnection sendSynchronousRequest:_request returningResponse:&response error:&error];

    if (nil != error)
    {
        NSLog(@"Error: %@", error);
    }
    else
    {
        NSError* error = nil;
        NSMutableDictionary* json = nil;
        NSString* dataString = [[NSString alloc] initWithData:_connectionData encoding:NSUTF8StringEncoding];
        NSLog(@"%@", dataString);

        if (nil != _connectionData)
        {
            json = [NSJSONSerialization JSONObjectWithData:_connectionData options:NSJSONReadingMutableContainers error:&error];
        }

        if (error || !json)
        {
            NSLog(@"Could not parse loaded json with error:%@", error);
        }

        NSLog(@"%@", json);
        _connectionData = nil;
    }

    [pool drain];

    return 0;
}

<?php
// This sample uses the PEAR HTTP client from http://pear.php.net/package/HTTP_Request2
require_once 'HTTP/Request2.php';

$request = new Http_Request2('https://api.sky.blackbaud.com/school/v1/athletics/schedules');
$url = $request->getUrl();

$headers = array(
    // Request headers
   'Bb-Api-Subscription-Key' => '{subscription key}',
   'Authorization' => 'Bearer {access token}',
);

$request->setHeader($headers);

$parameters = array(
    // Request parameters
    'start_date' => '{string}',
    'end_date' => '{string}',
    'school_year' => '{string}',
    'include_practice' => 'false',
    'team_id' => '0',
);

$url->setQueryVariables($parameters);

$request->setMethod(HTTP_Request2::METHOD_GET);

// Request body
$request->setBody("{body}");

try
{
    $response = $request->send();
    echo $response->getBody();
}
catch (HttpException $ex)
{
    echo $ex;
}

?>
########### Python 2.7 #############
import httplib, urllib, base64

headers = {
    # Request headers
    'Bb-Api-Subscription-Key': '{subscription key}',
    'Authorization': 'Bearer {access token}',
}

params = urllib.urlencode({
    # Request parameters
    'start_date': '{string}',
    'end_date': '{string}',
    'school_year': '{string}',
    'include_practice': 'false',
    'team_id': '0',
})

try:
    conn = httplib.HTTPSConnection('api.sky.blackbaud.com')
    conn.request("GET", "/school/v1/athletics/schedules?%s" % params, "{body}", headers)
    response = conn.getresponse()
    data = response.read()
    print(data)
    conn.close()
except Exception as e:
    print("[Errno {0}] {1}".format(e.errno, e.strerror))

####################################

########### Python 3.2 #############
import http.client, urllib.request, urllib.parse, urllib.error, base64

headers = {
    # Request headers
    'Bb-Api-Subscription-Key': '{subscription key}',
    'Authorization': 'Bearer {access token}',
}

params = urllib.parse.urlencode({
    # Request parameters
    'start_date': '{string}',
    'end_date': '{string}',
    'school_year': '{string}',
    'include_practice': 'false',
    'team_id': '0',
})

try:
    conn = http.client.HTTPSConnection('api.sky.blackbaud.com')
    conn.request("GET", "/school/v1/athletics/schedules?%s" % params, "{body}", headers)
    response = conn.getresponse()
    data = response.read()
    print(data)
    conn.close()
except Exception as e:
    print("[Errno {0}] {1}".format(e.errno, e.strerror))

####################################
require 'net/http'

uri = URI('https://api.sky.blackbaud.com/school/v1/athletics/schedules')

query = URI.encode_www_form({
    # Request parameters
    'start_date' => '{string}',
    'end_date' => '{string}',
    'school_year' => '{string}',
    'include_practice' => 'false',
    'team_id' => '0'
})
if query.length > 0
  if uri.query && uri.query.length > 0
    uri.query += '&' + query
  else
    uri.query = query
  end
end
request = Net::HTTP::Get.new(uri.request_uri)

# Request headers
request['Bb-Api-Subscription-Key'] = '{subscription key}'
request['Authorization'] = 'Bearer {access token}'

# Request body
request.body = "{body}"

response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
    http.request(request)
end

puts response.body

Comments

Have a question? See a problem with our docs? Want to engage with the SKY Developer team? Please visit us on the SKY Developer Community!