Overview

The Arbiter Partner API comprises a collection of RESTful endpoints that enable partner organizations to retrieve scheduling, assignment, and official data from the Arbiter platform. This API is designed to support secure and controlled system-to-system integration between Arbiter and its business partners, established through a formal agreement.

Getting started

Becoming a partner

A signed contract is required to initiate the use of the Partner API. Access is granted according to your organization’s requirements and the specific accounts needed (such as officiating groups, state offices, or schools). Please contact Arbiter at partner@arbitersports.com to commence the process. Upon approval, you will be provided with the necessary credentials and permissions to utilize the API for your integration.

API Explorer

You can use our Swagger as an API explorer to make calls to the partner api endpoints and view the results:

Production Swagger UI: https://partner.arbitersports.com/index.html

(OpenAPI at /swagger/v1/swagger.json)

Beta Swagger UI: https://partner.arbitersports-beta.com/index.html (OpenAPI at /swagger/v1/swagger.json)

Beta mirrors Production Swagger; suitable for functional testing. However, the data is scrubbed and randomized so the actual returns will not be accurate to the account.

Environments

Production Swagger UI: https://partner.arbitersports.com/index.html (OpenAPI at /swagger/v1/swagger.json)
Beta Swagger UI: https://partner.arbitersports-beta.com/index.html (OpenAPI at /swagger/v1/swagger.json) Beta mirrors Production Swagger; suitable for functional testing. However, the data is scrubbed and randomized so the actual returns will not be accurate to the account.

Scopes

Endpoints require one of: Scheduling, Registration, Eligibility. Partners get scopes enabled per integration purpose; data access is limited to allowlisted accounts (groups/schools/state offices).

Rate Limit & Pagination

Rate limit: 2,000 calls/hour per partner.
Pagination: Not supported in V1; use frequent incremental polling every 5 minutes to keep payloads small and experiences near‑realtime.

Authentication (OAuth2 client credentials)
Polling Strategy (near‑realtime via lastModifiedDate)
Error Handling & 404 Semantics
Endpoint Catalog & Examples
- Assignment
- CustomField
- Eligibility
- EligibilityTier
- Identity
- Organization
- Resources
- Schedule
- Status
- User / Officials / Staff / Students
Field‑Level JSON (Reference Models)
Best Practices (technical & business outcomes)
Quick Start

1) Authentication (OAuth2 – Client Credentials)

Use client credentials to obtain a Bearer access token, then pass it in the Authorization header for all calls.

Token Endpoints

Prod: https://token.arbitersports.com/connect/token
Beta: https://token.arbitersports-beta.com/connect/token\ In Swagger UI, click Authorize and paste Bearer <access_token>.

cURL – Get Token (Prod)

curl --location 'https://token.arbitersports.com/connect/token' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode 'client_id={{client_id}}' \
--data-urlencode 'client_secret={{client_secret}}' \
--data-urlencode 'grant_type=client_credentials' \
--data-urlencode 'scope=Registration Eligibility Assigning Scheduling '

Sample Token Response

{
  "accesstoken": "eyJhbGciOi…snip…",
  "expiresin": 3600,
  "token_type": "Bearer",
  "scope": "Scheduling"
}

ASCII Flow Diagram

+-------------+       POST client_id/secret/scope        +---------------------------+
|   Partner   | ---------------------------------------> | token.arbitersports.com   |
| Application |                                          | /connect/token            |
+-------------+                                          +---------------------------+
        |                          200 OK: access_token (Bearer)
        | <----------------------------------------------------------- 
        | 
        |  GET/POST ... with Authorization: Bearer <access_token>
        v
+-----------------------------+
| partner.arbitersports.com   |
| (Scoped API endpoints)      |
+-----------------------------+

Implementation Tips:

Scope minimization: request only what you actually need.

Token caching: reuse until expires_in to avoid overhead and protect the rate limit.

Account allowlists: expect rejections if you query accounts you aren’t enabled for.

2) Polling Strategy (near‑realtime via `lastModifiedDate`)

Filter: lastModifiedDate
Cadence: every 5 minutes
Overlap: Requery from (lastSuccessfulPollAt - 6) to cover clock skew and late writes.
De‑dupe: Use stable IDs (e.g., UniqueGameID) to reconcile overlapping windows.\ This approach is recommended for GetGames and GetAssignments to reduce server load and deliver near‑realtime experiences.

Python – 5‑min polling with consistent lastModifiedDate casing

import requests
from datetime import datetime, timedelta, timezone

TOKEN = "REPLACEME"
lastsuccess = datetime.now(timezone.utc) - timedelta(minutes=5)
overlap = timedelta(minutes=3)  # choose 2–5 minutes
querytime = (lastsuccess - overlap).isoformat().replace("+00:00", "Z")

params = {"lastModifiedDate": querytime}
res = requests.get(
    "https://partner.arbitersports.com/api/Game/GetGames",
    headers={"Authorization": f"Bearer {TOKEN}", "Accept": "application/json"},
    params=params,
    timeout=30
)

if res.statuscode == 404:
    print("No updates in this window.")
else:
    res.raiseforstatus()
    for game in res.json():
        # upsert game by UniqueGameID; handle deletions via DeletedGames endpoint
        pass

3) Error Handling & 404 Semantics

Standard error envelope (used in examples)\ (Endpoints may return different bodies; see Field‑Level JSON for endpoint‑specific shapes.)

Special behavior:

404 Not Found is returned when no records match your filter window—even if the endpoint URL and parameters are valid. Treat 404 as “no data for this poll”; continue the 5‑minute cadence. (Behavior documented in Arbiter guidance.)

{
  "error": {
    "code": "NotFound",
    "message": "No records matched the filter.",
    "details": [
      { "field": "lastModifiedDate", "issue": "No changes since 2025-11-19T18:00:00Z" }
    ],
    "requestId": "a1b2c3d4e5f6"
  }

4) Endpoint Catalog & Examples

The list below mirrors the public Swagger UI sections and operations. Sample requests/responses use placeholder IDs and consistent lastModifiedDate casing. Adjust quickly once you paste your canonical field names from the OpenAPI spec.

Legend

Scope: expected scope (confirm in your spec)
Common filters: typical query parameters; prefer lastModifiedDate for incremental sync
Business outcome tips: how to use the endpoint in a production integration

A. Assignment

1) GET /api/Assignment/GetAssignmentsByUniqueGameIds

Scope: Scheduling
Purpose: Pull assignments for a set of known games using UniqueGameIDs.
Sample response (placeholder fields):

[
  {
    "assignmentId": "ASSIGN-001",
    "uniqueGameId": "GAME-ABC-123",
    "officialId": "OFF-1001",
    "role": "Referee",
    "status": "Assigned",
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  }
]

cURL

curl -G "https://partner.arbitersports.com/api/Assignment/GetAssignmentsByUniqueGameIds" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "uniqueGameIds=GAME-ABC-123,GAME-XYZ-999"

2) GET /api/Assignment/GetAssignments

Scope: Scheduling
Purpose: Poll assignment changes across accounts you’re allowed to access.
Best practice: Use lastModifiedDate to query every 5 minutes for recent changes
Sample response:

[
  {
    "assignmentId": "ASSIGN-002",
    "uniqueGameId": "GAME-ABC-123",
    "officialId": "OFF-1002",
    "role": "Umpire",
    "status": "Pending",
    "lastModifiedDate": "2025-11-19T18:07:12Z"
  }
]

cURL

curl -G "https://partner.arbitersports.com/api/Assignment/GetAssignments" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "lastModifiedDate=2025-11-19T18:05:00Z"

3) GET /api/Assignment/GetWorkerAssignments

Scope: Scheduling
Purpose: Fetch assignments for a specified worker/official (e.g., to power a user dashboard).
Best practice: Use lastModifiedDate to query every 5 minutes for recent changes
Sample response:

[
  {
    "assignmentId": "ASSIGN-050",
    "uniqueGameId": "GAME-DEF-456",
    "officialId": "OFF-2001",
    "role": "Referee",
    "status": "Assigned",
    "startDateTime": "2025-11-24T01:30:00Z",
    "siteId": "SITE-77",
    "levelId": "LEVEL-VARSITY",
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  }
]

Business outcome:\ Sync games first, then assignments, and consider OfficialBlock (availability) to prevent double‑booking.

B. CustomField

1) GET /api/CustomField/{groupId}/all

Scope: Registration (confirm)
Purpose: List all custom field definitions for a group.
Path param: groupId
Sample response:

  { "name": "CertificationNumber", "type": "string", "required": false },
  { "name": "YearsExperience", "type": "integer", "required": false }

2) POST /api/CustomField/{groupId}

Scope: Registration (confirm)
Purpose: Create or update a single field definition.
Request body (example):

{
  "name": "BackgroundCheckDate",
  "type": "date",
  "required": true
}

cURL

curl -X POST "https://partner.arbitersports.com/api/CustomField/12345" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \

3) POST /api/CustomField/{groupId}/multi

Scope: Registration (confirm)
Purpose: Bulk create/update multiple field definitions—ideal for onboarding.
Request body (example):

[
  { "name": "JerseySize", "type": "string", "required": false, "enum": ["S","M","L","XL"] },
  { "name": "IsCertifiedTrainer", "type": "boolean", "required": false }
]

C. Eligibility

1) GET /api/Eligibility/GetGroupEligibilities

Scope: Eligibility
Purpose: List eligibility statuses for users in a group.
Params: groupId, optional filters (e.g., lastModifiedDate)
Response:

[
  { "userId": "USER-1001", "tierId": "TIER-200", "status": "Eligible", "lastModifiedDate": "2025-11-19T18:04:00Z" }
]

2) POST `/api/Eligibility/GrantEligibility``

Scope: Eligibility
Body:

{ "userId": "USER-1001", "tierId": "TIER-200" }

3) POST /api/Eligibility/RemoveEligibility

Scope: Eligibility
Body:

{ "userId": "USER-1001", "tierId": "TIER-200" }

4) GET /api/Official/Eligibility

Scope: Eligibility
Purpose: Retrieve eligibility status specifically for officials.

Business outcome:\ Enforce eligibility before assignment; log changes (who/when/why) for compliance audits.

D. EligibilityTier

Overview: Endpoints to manage tiered eligibility programs (view tiers, mark requirements complete, unenroll users, and list officials within tiers). Use these alongside Eligibility endpoints to enforce qualification before assignments.

1) GET `/api/eligibility/tier/eligibilitytiers`

Scope: Eligibility
Purpose: Retrieve available eligibility tiers (e.g., background checks, certifications, training modules) so you can present or validate program requirements.
Parameters: GroupID
Sample response (placeholder fields):

[
  {
    "tierId": "TIER-200",
    "name": "Varsity Officiating Certification",
    "description": "Annual certification required for varsity assignments.",
    "requirements": [
      { "requirementId": "REQ-12", "name": "Background Check", "mandatory": true },
      { "requirementId": "REQ-19", "name": "Concussion Training", "mandatory": true }
    ],
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  }
]

cURL

curl "https://partner.arbitersports.com/api/eligibility/tier/eligibilitytiers" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
res = requests.get(
  "https://partner.arbitersports.com/api/eligibility/tier/eligibilitytiers",
  headers={"Authorization": f"Bearer {TOKEN}"}
)
print("No tiers." if res.status_code == 404 else res.json())

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/eligibility/tier/eligibilitytiers", {
  headers: { Authorization: Bearer ${TOKEN} }
});
console.log(res.status === 404 ? "No tiers." : await res.json());

2) POST `/api/eligibility/tier/markcomplete`

Scope: Eligibility
Purpose: Mark a requirement complete for a user within a given tier (e.g., user finished training). Use this to advance the user toward eligibility.
Request body (example):

{
  "userId": "USER-1001",
  "tierId": "TIER-200",
  "requirementId": "REQ-12",
  "completedAt": "2025-11-19T18:02:00Z",
  "evidenceUrl": "https://files.example.org/certificates/USER-1001-REQ-12.pdf"
}

cURL

curl -X POST "https://partner.arbitersports.com/api/eligibility/tier/markcomplete" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{ "userId": "USER-1001", "tierId": "TIER-200", "requirementId": "REQ-12", "completedAt": "2025-11-19T18:02:00Z" }'

Python

import requests, json
payload = {
  "userId": "USER-1001",
  "tierId": "TIER-200",
  "requirementId": "REQ-12",
  "completedAt": "2025-11-19T18:02:00Z"
}
res = requests.post(
  "https://partner.arbitersports.com/api/eligibility/tier/markcomplete",
  headers={"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"},
  data=json.dumps(payload)
)
print(res.json() if res.status_code < 400 else res.text)

JavaScript

const payload = {
  userId: "USER-1001",
  tierId: "TIER-200",
  requirementId: "REQ-12",
  completedAt: "2025-11-19T18:02:00Z"
};
const res = await fetch("https://partner.arbitersports.com/api/eligibility/tier/markcomplete", {
  method: "POST",
  headers: { Authorization: Bearer ${TOKEN}, "Content-Type": "application/json" },
  body: JSON.stringify(payload)
});
console.log(await res.json());

3) POST `/api/eligibility/tier/unenrolluser`

Scope: Eligibility
Purpose: Unenroll a user from a tier (e.g., failure to complete requirements by deadline, or removal from program).
Request body (example):

{
  "userId": "USER-1001",
  "tierId": "TIER-200",
  "reason": "Expired certification"
}

cURL

curl -X POST "https://partner.arbitersports.com/api/eligibility/tier/unenrolluser" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{ "userId": "USER-1001", "tierId": "TIER-200", "reason": "Expired certification" }'

Python

import requests, json
payload = { "userId": "USER-1001", "tierId": "TIER-200", "reason": "Expired certification" }
res = requests.post(
  "https://partner.arbitersports.com/api/eligibility/tier/unenrolluser",
  headers={"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"},
  data=json.dumps(payload)
)
print(res.json() if res.status_code < 400 else res.text)

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/eligibility/tier/unenrolluser", {
  method: "POST",
  headers: { Authorization: Bearer ${TOKEN}, "Content-Type": "application/json" },
  body: JSON.stringify({ userId: "USER-1001", tierId: "TIER-200", reason: "Expired certification" })
});
console.log(await res.json());

4) GET `/api/eligibility/tier/officials`

Scope: Eligibility
Purpose: List officials associated with eligibility tiers—useful to determine who is ready for certain assignments (e.g., varsity games).
Best Practice: Use the lastModifiedDate to get the updated completions every hour.
Sample response (placeholder fields):

[
  {
    "tierId": "TIER-200",
    "officialId": "OFF-2001",
    "status": "Eligible",
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  },
  {
    "tierId": "TIER-200",
    "officialId": "OFF-2002",
    "status": "InProgress",
    "lastModifiedDate": "2025-11-19T18:04:00Z"
  }
]

cURL

curl -G "https://partner.arbitersports.com/api/eligibility/tier/officials" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "tierId=TIER-200"

Python

import requests
res = requests.get(
  "https://partner.arbitersports.com/api/eligibility/tier/officials",
  headers={"Authorization": f"Bearer {TOKEN}"},
  params={"tierId": "TIER-200"}
)
print("No officials for tier." if res.status_code == 404 else res.json())

JavaScript

const url = new URL("https://partner.arbitersports.com/api/eligibility/tier/officials");
url.searchParams.set("tierId", "TIER-200");
const res = await fetch(url, { headers: { Authorization: Bearer [Token] }});
console.log(res.status === 404 ? "No officials for tier." : await res.json());

Usage Tips (business outcomes)

Gate assignments by eligibility: Before running assignment logic, query officials by tier and confirm required statuses (e.g., everything in “Eligible” for varsity).
Automate completion updates: Pair workflow systems (LMS/background check providers) with markcomplete to keep Arbiter eligibility current.
Audit trails: If your downstream systems need audits, capture timestamps (completedAt) and requirementId in your change logs for review.

F. Organization

Overview: Endpoints to retrieve groups (organizations), their alignment (parent/child relationships), and schools (including partner ID mappings). These are great candidates for caching (e.g., daily) because they change infrequently and are referenced by other domains like Schedule, Assignments, and Resources.

1) GET `/api/Group`

Scope: none
Purpose: Retrieve group (organization) metadata (e.g., association, conference, officiating group) for accounts you’re allowed to access. Use this to resolve display names and to scope downstream calls.
Parameters: GroupID
Sample response (placeholder fields):

[
  {
    "groupId": "GRP-100",
    "name": "Metro Officials Association",
    "type": "OfficiatingGroup",
    "region": "Region 5",
    "contactEmail": "office@metroofficials.org",
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  },
  {
    "groupId": "GRP-101",
    "name": "Central Valley Athletics",
    "type": "AthleticAssociation",
    "region": "Central",
    "contactEmail": "info@cva.example.org",
    "lastModifiedDate": "2025-11-19T18:06:00Z"
  }
]

cURL

curl "https://partner.arbitersports.com/api/Group" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
res = requests.get(
  "https://partner.arbitersports.com/api/Group",
  headers={"Authorization": f"Bearer {TOKEN}"}
)

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Group", {
  headers: { Authorization: Bearer [token] }
});
console.log(res.status === 404 ? "No groups." : await res.json());

2) GET `/api/Group/alignment`

Scope: Scheduling
Purpose: Retrieve alignment metadata (parent/child relationships among groups). Use to understand organizational hierarchies—e.g., which subgroups (regions/leagues) belong to a state association.
Parameters: GroupID
Sample response (placeholder fields):

{
  "parentGroupId": "GRP-ROOT",
  "children": [
    { "groupId": "GRP-100", "name": "Metro Officials Association" },
    { "groupId": "GRP-101", "name": "Central Valley Athletics" }
  ],
  "lastModifiedDate": "2025-11-19T18:05:00Z"
}

cURL

curl "https://partner.arbitersports.com/api/Group/alignment" \
  -H "Authorization: Bearer $TOKEN"

Python

impot requests
res = requests.get(
  "https://partner.arbitersports.com/api/Group/alignment",
  headers={"Authorization": f"Bearer {TOKEN}"}
)
print("No alignment." if res.status_code == 404 else res.json())

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Group/alignment", {
  headers: { Authorization: Bearer [token] }
});
console.log(res.status === 404 ? "No alignment." : await res.json());

3) GET `/api/School/GetAllSchools`

Scope: Scheduling (common reference data across scheduling, registration, eligibility)
Purpose: Retrieve all schools available within your allowed accounts. Use to populate drop‑downs, match external SIS/HR systems, and enrich game data with school names.
Parameters: Required to provide either school ID or state.
Sample response (placeholder fields):

[
  {
    "schoolId": "SCH-567",
    "name": "Oak Ridge High School",
    "district": "Oak Ridge Unified",
    "address": "1234 Elm St, Oak Ridge, UT",
    "partnerIds": { "sisId": "ORHS-001" },
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  },
  {
    "schoolId": "SCH-568",
    "name": "Cedar Valley High School",
    "district": "Cedar Valley Unified",
    "address": "987 Pine Ave, Cedar Valley, UT",
    "partnerIds": { "sisId": "CVHS-001" },
    "lastModifiedDate": "2025-11-19T18:06:00Z"
  }

cURL

curl "https://partner.arbitersports.com/api/School/GetAllSchools" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
res = requests.get(
  "https://partner.arbitersports.com/api/School/GetAllSchools",
  headers={"Authorization": f"Bearer {TOKEN}"}
)

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/School/GetAllSchools", {
  headers: { Authorization: Bearer [token] }
});
console.log(res.status === 404 ? "No schools." : await res.json());

4) GET `/api/School/GetPartnerIdsForSchools`

Scope: Scheduling (cross‑system mapping)
Purpose: Retrieve partner ID mappings for schools (e.g., SIS/HR/external system identifiers) to ensure consistent cross‑system joins and deduplication.
Parameters: SchoolID
Sample response (placeholder fields):

[
  {
    "schoolId": "SCH-567",
    "partnerIds": {
      "sisId": "ORHS-001",
      "erpId": "ERPOR-12",
      "districtCode": "ORUSD"
    },
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  },
  {
    "schoolId": "SCH-568",
    "partnerIds": {
      "sisId": "CVHS-001",
      "erpId": "ERPCV-34",
      "districtCode": "CVUSD"
    },
    "lastModifiedDate": "2025-11-19T18:06:00Z"
  }

cURL

curl "https://partner.arbitersports.com/api/School/GetPartnerIdsForSchools" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
res = requests.get(
  "https://partner.arbitersports.com/api/School/GetPartnerIdsForSchools",
  headers={"Authorization": f"Bearer {TOKEN}"}
)
print("No partner IDs." if res.status_code == 404 else res.json())

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/School/GetPartnerIdsForSchools", {
  headers: { Authorization: Bearer [token] }
});
console.log(res.status === 404 ? "No partner IDs." : await res.json());

Organization Data Usage Tips

Cache org data (Groups, Schools, Partner IDs) daily; it’s referenced by Schedule and Assignments, but changes relatively infrequently.

G. Resources

Overview: Metadata and roster endpoints used by scheduling and assignment flows—crews, sports taxonomy, and teams/rosters. These are typically lower‑volume and excellent candidates for caching (e.g., 24 hours) to reduce load and latency.

1) GET `/api/Official/GetCrews`

Scope: Scheduling (commonly used alongside assignments)
Purpose: Retrieve officiating crews . Use to display or validate crew‑based assignments and to power UI filters.
Sample response (placeholder fields):

[
  {
    "crewId": "CREW-33",
    "name": "Region 5 Varsity Crew",
    "officialIds": ["OFF-2001", "OFF-2002", "OFF-2003"],
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  }
]

cURL

curl "https://partner.arbitersports.com/api/Official/GetCrews" \

Python

import requests
res = requests.get(
  "https://partner.arbitersports.com/api/Official/GetCrews",
  headers={"Authorization": f"Bearer {TOKEN}"}
)
print("No crews." if res.status_code == 404 else res.json())

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Official/GetCrews", {
  headers: { Authorization: Bearer [Token] }
});
console.log(res.status === 404 ? "No crews." : await res.json());

2) GET `/api/Sport/GetGenericSports`

Scope: none
Purpose: Retrieve sports taxonomy (IDs/codes + names). Cache and use to normalize downstream analytics, filters, and UI labels.
Sample response:

[
  { "sportId": "SPORT-FB",  "name": "Football" },
  { "sportId": "SPORT-BKB", "name": "Basketball" },
  { "sportId": "SPORT-SOC", "name": "Soccer" }
]

cURL

curl "https://partner.arbitersports.com/api/Sport/GetGenericSports" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
res = requests.get(
  "https://partner.arbitersports.com/api/Sport/GetGenericSports",
  headers={"Authorization": f"Bearer {TOKEN}"}
)
print(res.json())

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Sport/GetGenericSports", {
  headers: { Authorization: Bearer [token] }
});
const sports = await res.json();
console.table(sports);

3) GET `/api/Team/GetTeams`

Scope: Scheduling (roster & team reference)
Purpose: Retrieve teams available in allowed accounts. Use as a reference list for games, assignments, and eligibility checks.
Common params:
- groupId (if available)
- schoolId (if available)
- (Optionally) lastModifiedDate for incremental changes
Sample response (placeholder fields):

[
  {
    "teamId": "TEAM-HT-200",
    "name": "Hawks Varsity",
    "schoolId": "SCH-567",
    "sportId": "SPORT-BKB",
    "levelId": "LEVEL-VARSITY",
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  },
  {
    "teamId": "TEAM-AT-300",
    "name": "Bears JV",
    "schoolId": "SCH-568",
    "sportId": "SPORT-BKB",
    "levelId": "LEVEL-JV",
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  }
]

cURL

curl "https://partner.arbitersports.com/api/Team/GetTeams" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
res = requests.get(
  "https://partner.arbitersports.com/api/Team/GetTeams",
  headers={"Authorization": f"Bearer {TOKEN}"}
)

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Team/GetTeams", {
  headers: { Authorization: Bearer [token] }
});

4) GET `/api/Team/GetTeamWithRosters`

Scope: Scheduling
Purpose: Retrieve a single team with full roster details (players, positions, jersey numbers). Use for compliance/eligibility checks and enriched UI presentations.
Parameters: teamId (required)
Sample response (placeholder fields):

{
  "teamId": "TEAM-123",
  "name": "Hawks Varsity",
  "schoolId": "SCH-567",
  "sportId": "SPORT-BKB",
  "levelId": "LEVEL-VARSITY",
  "roster": [
    { "playerId": "PL-001", "firstName": "Alex", "lastName": "Lee", "number": 12, "position": "G" },
    { "playerId": "PL-002", "firstName": "Sam",  "lastName": "Rivera", "number": 33, "position": "F" }
  ],
  "lastModifiedDate": "2025-11-19T18:05:00Z"
}

cURL

curl -G "https://partner.arbitersports.com/api/Team/GetTeamWithRosters" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "teamId=TEAM-123"

Python

import requests
res = requests.get(
  "https://partner.arbitersports.com/api/Team/GetTeamWithRosters",
  headers={"Authorization": f"Bearer {TOKEN}"},
  params={"teamId": "TEAM-123"}
)
print("Team not found." if res.status_code == 404 else res.json())

JavaScript

const url = new URL("https://partner.arbitersports.com/api/Team/GetTeamWithRosters");
url.searchParams.set("teamId", "TEAM-123");
const res = await fetch(url, { headers: { Authorization: Bearer [token]}});
console.log(res.status === 404 ? "Team not found." : await res.json());

Resource Usage Tips (business outcomes)

Cache sports, levels (from Status section), and crews; they change infrequently and can be refreshed on demand.
Use Team/roster data to validate eligibility/roster compliance prior to assignments and game publication.
Reference sport/level consistently across Game and Assignment endpoints to keep analytics clean.

H. Schedule

Overview: Endpoints to retrieve events, games (and their lifecycle/history), tournaments, and official availability blocks. For near‑realtime integrations, poll GetGames and DeletedGames using lastModifiedDate every 5 minutes.

1) GET `/api/Event/GetEvents`

Scope: Scheduling
Purpose: Retrieve events across accounts you’re allowed to access. Use when you need non‑game schedule items (ceremonies, meetings, practices, etc.).
Best practice: Use lastModifiedDate to query every 5 minutes for recent changes
Sample response (placeholder fields):

[
  {
    "eventId": "EVT-001",
    "name": "Preseason Meeting",
    "associationId": "ASSOC-10",
    "siteId": "SITE-77",
    "startDateTime": "2025-11-24T01:30:00Z",
    "endDateTime": "2025-11-24T03:00:00Z",
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  }
]

cURL

curl -G "https://partner.arbitersports.com/api/Event/GetEvents" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "startDate=2025-11-01" \
  --data-urlencode "endDate=2025-11-30"

Python

import requests
res = requests.get(
  "https://partner.arbitersports.com/api/Event/GetEvents",
  headers={"Authorization": f"Bearer {TOKEN}"},
  params={"startDate": "2025-11-01", "endDate": "2025-11-30"}
)

JavaScript

const url = new URL("https://partner.arbitersports.com/api/Event/GetEvents");
url.searchParams.set("startDate", "2025-11-01");
url.searchParams.set("endDate", "2025-11-30");
const res = await fetch(url, { headers: { Authorization: Bearer [token] }});

2) GET `/api/Event/GetAssociationEvents`

Scope: Scheduling
Purpose: Retrieve events scoped to a specific association (useful when you partition by governing body).
Common params: associationId, startDate, endDate
Sample response:

[
  {
    "eventId": "EVT-020",
    "associationId": "ASSOC-20",
    "name": "Officials Clinic",
    "siteId": "SITE-12",
    "startDateTime": "2025-11-26T17:00:00Z",
    "lastModifiedDate": "2025-11-19T18:09:00Z"
  }
]

cURL

curl -G "https://partner.arbitersports.com/api/Event/GetAssociationEvents" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "associationId=ASSOC-20" \
  --data-urlencode "startDate=2025-11-01" \

3) GET `/api/Game/GetGamesByUniqueGameIds`

Scope: Scheduling
Purpose: Retrieve games by explicit UniqueGameIDs (precise re‑fetch after a delta list or for troubleshooting).
Parameters: uniqueGameIds=GUID1,GUID2,...
Sample response:

[
  {
    "uniqueGameId": "GAME-ABC-123",
    "gameNumber": "2025-000987",
    "sportId": "SPORT-SOC",
    "levelId": "LEVEL-VARSITY",
    "homeTeamId": "TEAM-HT-200",
    "awayTeamId": "TEAM-AT-300",
    "siteId": "SITE-77",
    "startDateTime": "2025-11-24T01:30:00Z",
    "status": "Scheduled",
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  }
]

cURL

curl -G "https://partner.arbitersports.com/api/Game/GetGamesByUniqueGameIds" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "uniqueGameIds=GAME-ABC-123,GAME-XYZ-999"

4) GET `/api/Game/GetGames`

Scope: Scheduling
Purpose: Primary game feed—use lastModifiedDate and poll every 5 minutes to keep downstream systems current while minimizing payloads.
Best practice: Use lastModifiedDate to query every 5 minutes for recent changes
Sample response:

[
  {
    "uniqueGameId": "GAME-DEF-456",
    "gameNumber": "2025-000654",
    "sportId": "SPORT-BKB",
    "levelId": "LEVEL-JV",
    "homeTeamId": "TEAM-HT-210",
    "awayTeamId": "TEAM-AT-305",
    "siteId": "SITE-12",
    "startDateTime": "2025-11-27T19:00:00Z",
    "status": "Scheduled",
    "lastModifiedDate": "2025-11-19T18:06:30Z"
  }
]

cURL

curl -G "https://partner.arbitersports.com/api/Game/GetGames" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "lastModifiedDate=2025-11-19T18:05:00Z"

Python (404 = no data)

import requests
res = requests.get(
  "https://partner.arbitersports.com/api/Game/GetGames",
  headers={"Authorization": f"Bearer {TOKEN}"},
  params={"lastModifiedDate": "2025-11-19T18:05:00Z"}
)

5) GET `/api/Game/GameTypes`

Scope: Scheduling
Purpose: Retrieve taxonomy of game types (regular season, playoff, scrimmage, etc.) to normalize downstream analytics and UI filters.
Sample response:

[
  { "gameTypeId": "REGULAR", "name": "Regular Season" },
  { "gameTypeId": "PLAYOFF", "name": "Playoff" }
]

cURL

curl "https://partner.arbitersports.com/api/Game/GameTypes" \
  -H "Authorization: Bearer $TOKEN"

6) GET `/api/Game/DeletedGames`

Scope: Scheduling
Purpose: Return deleted games for reconciliation—critical for keeping external calendars consistent. Poll alongside GetGames with lastModifiedDate.
Best practice: Use lastModifiedDate to query every 5 minutes for recent changes
Sample response:

[
  {
    "uniqueGameId": "GAME-XYZ-999",
    "deletedAt": "2025-11-18T10:00:00Z",
    "reason": "Canceled"
  }
]

cURL

curl -G "https://partner.arbitersports.com/api/Game/DeletedGames" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "lastModifiedDate=2025-11-19T18:05:00Z"

7) GET `/api/Game/GetTournaments`

Scope: Scheduling
Purpose: Retrieve tournament metadata (name, rounds, related games). Use to enrich bracket views or consolidate multi‑game events.
Common params: startDate, endDate, (optionally) lastModifiedDate
Sample response:

[
  {
    "tournamentId": "TRN-44",
    "name": "Holiday Classic",
    "startDate": "2025-12-20",
    "endDate": "2025-12-22",
    "games": ["GAME-TRN-1001", "GAME-TRN-1002"],
    "lastModifiedDate": "2025-11-19T18:08:00Z"
  }

cURL

curl -G "https://partner.arbitersports.com/api/Game/GetTournaments" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "startDate=2025-12-01" \
  --data-urlencode "endDate=2025-12-31"

8) GET `/api/Game/GetGameHistory`

Scope: Scheduling
Purpose: Retrieve change history for a single game (time changes, site swaps, status updates). Use to power audit views and to resolve discrepancies.
Common params: uniqueGameId
Sample response:

[
  {
    "uniqueGameId": "GAME-DEF-456",
    "changedAt": "2025-11-19T17:55:00Z",
    "field": "startDateTime",
    "oldValue": "2025-11-27T18:00:00Z",
    "newValue": "2025-11-27T19:00:00Z",
    "changedBy": "ASSIGNER-201"
  }
]

cURL

curl -G "https://partner.arbitersports.com/api/Game/GetGameHistory" \
  -H "Authorization: Bearer $TOKEN" \

9) GET `/api/Game/GetGameTeamHistory`

Scope: Scheduling
Purpose: Retrieve team‑side history (e.g., roster or team association changes linked to a game). Useful for eligibility/roster compliance reviews.
Common params: uniqueGameId
Sample response:

[
  {
    "uniqueGameId": "GAME-DEF-456",
    "changedAt": "2025-11-19T17:40:00Z",
    "teamId": "TEAM-HT-210",
    "field": "roster",
    "oldValue": "PL-001,PL-002,PL-003",
    "newValue": "PL-001,PL-002,PL-010",
    "changedBy": "COACH-77"
  }
]

cURL

curl -G "https://partner.arbitersports.com/api/Game/GetGameTeamHistory" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "uniqueGameId=GAME-DEF-456"

10) GET `/api/Official/OfficialBlock`

Scope: Scheduling
Purpose: Retrieve official availability blocks to prevent conflicting assignments. Use alongside GetAssignments.
Common params: officialId, startDate, endDate
Sample response:

[
  { "officialId": "OFF-2001", "start": "2025-11-25T00:00:00Z", "end": "2025-11-25T23:59:59Z", "reason": "Travel" }
]

cURL

curl -G "https://partner.arbitersports.com/api/Official/OfficialBlock" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "officialId=OFF-2001" \
  --data-urlencode "startDate=2025-11-01" \

I. Status

Overview: Status endpoints provide platform metadata (levels, site types, app version/health). These are low‑churn and great candidates for caching (e.g., daily), but they’re critical references for Schedule and Assignment integrations.

1) GET `/api/Level/GetLevels`

Scope: Scheduling
Purpose: Retrieve competition levels (e.g., Varsity, JV, Middle School). Use to normalize analytics, UI filters, and validations on games and assignments.
Common params: (Typically none; some implementations may allow group filters—confirm in spec.)
Sample response (placeholder fields):

[
  { "levelId": "LEVEL-VARSITY", "name": "Varsity", "displayOrder": 1 },
  { "levelId": "LEVEL-JV",      "name": "Junior Varsity", "displayOrder": 2 },
  { "levelId": "LEVEL-MS",      "name": "Middle School", "displayOrder": 3 }
]

cURL

curl "https://partner.arbitersports.com/api/Level/GetLevels" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
res = requests.get("https://partner.arbitersports.com/api/Level/GetLevels",
                   headers={"Authorization": f"Bearer {TOKEN}"})
print("No levels." if res.status_code == 404 else res.json())

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Level/GetLevels", {
  headers: { Authorization: Bearer ${TOKEN} }
});
console.log(res.status === 404 ? "No levels." : await res.json());

2) GET `/api/Maint/AppVersion` & HEAD `/api/Maint/AppVersion`

Scope: Scheduling (platform health/metadata)
Purpose: Check application version and service liveliness. GET returns version metadata; HEAD can be used for a lightweight health probe (no body). Useful for support diagnostics and CI monitors.
Parameters: (None)
Sample response (GET, placeholder fields):

{
  "version": "1.0.0",
  "buildDate": "2025-10-31T12:00:00Z",
  "commit": "abc123def"
}

cURL (GET)

curl "https://partner.arbitersports.com/api/Maint/AppVersion" \
  -H "Authorization: Bearer $TOKEN"

cURL (HEAD)

curl -I "https://partner.arbitersports.com/api/Maint/AppVersion" \
  -H "Authorization: Bearer $TOKEN"

Python (GET)

import requests
res = requests.get("https://partner.arbitersports.com/api/Maint/AppVersion",
                   headers={"Authorization": f"Bearer {TOKEN}"})
print(res.json())

JavaScript (HEAD)

const res = await fetch("https://partner.arbitersports.com/api/Maint/AppVersion", {
  method: "HEAD",
  headers: { Authorization: Bearer [token] }
});
console.log(Status: ); // 200 OK -> service reachable

3) GET `/api/Site/SiteTypes`

Scope: Scheduling (taxonomy)
Purpose: Retrieve site type (e.g., stadium, gym, field) to classify venues and drive UI filters/analytics.
Parameters: none
Sample response:

[
  { "siteTypeId": "STADIUM", "name": "Stadium" },
  { "siteTypeId": "GYM",     "name": "Gymnasium" },
  { "siteTypeId": "FIELD",   "name": "Field" }
]

cURL

curl "https://partner.arbitersports.com/api/Site/SiteTypes" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
res = requests.get("https://partner.arbitersports.com/api/Site/SiteTypes",
                   headers={"Authorization": f"Bearer {TOKEN}"})
print(res.json())

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Site/SiteTypes", {
  headers: { Authorization: Bearer [token] }
});
console.table(await res.json());

4) GET `/api/Site/SubSiteTypes`

Scope: Scheduling (taxonomy)
Purpose: Retrieve sub‑site types (e.g., auxiliary gym, practice field)—a finer categorization under SiteTypes. Use for venue selection and resource planning.
Common params: (None)
Sample response:

[
  { "subSiteTypeId": "AUXGYM", "name": "Auxiliary Gym", "parentSiteTypeId": "GYM" },
  { "subSiteTypeId": "PRACTICEFIELD", "name": "Practice Field", "parentSiteTypeId": "FIELD" }
]

cURL

curl "https://partner.arbitersports.com/api/Site/SubSiteTypes" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
res = requests.get("https://partner.arbitersports.com/api/Site/SubSiteTypes",
                   headers={"Authorization": f"Bearer {TOKEN}"})
print(res.json())

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Site/SubSiteTypes", {
  headers: { Authorization: Bearer [token] }
});
console.table(await res.json());

5) GET `/api/Site`

Scope: Scheduling
Purpose: Retrieve sites (venues) that appear in games/events. Use to populate UI pickers, validate game payloads, and enrich schedules with location detail.
Parameters: SiteID or State are required
Sample response (placeholder fields):

[
  {
    "siteId": "SITE-77",
    "name": "Monroe Stadium",
    "siteTypeId": "STADIUM",
    "subSiteTypeId": null,
    "address": "9815 S Monroe St, Sandy, UT",
    "capacity": 4500,
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  },
  {
    "siteId": "SITE-12",
    "name": "Centennial Gym",
    "siteTypeId": "GYM",
    "subSiteTypeId": "AUX_GYM",
    "address": "100 E Campus Dr, Sandy, UT",
    "capacity": 1200,
    "lastModifiedDate": "2025-11-19T18:07:30Z"
  }
]

cURL

curl "https://partner.arbitersports.com/api/Site" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
res = requests.get("https://partner.arbitersports.com/api/Site",
                   headers={"Authorization": f"Bearer {TOKEN}"})

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Site", {
  headers: { Authorization: Bearer [token] }
});
console.log(res.status === 404 ? "No sites." : await res.json());

Usage Tips (business outcomes)

Cache taxonomies (GetLevels, SiteTypes, SubSiteTypes) daily; they change infrequently but drive consistency in Game and Assignment records.
Validate payloads: when ingesting games, confirm levelId, siteId, and siteTypeId exist to prevent downstream data issues.
Health checks: wire HEAD /api/Maint/AppVersion into monitoring to quickly detect outages; use GET for diagnosing version/build information.

J. User / Officials / Staff / Students

Overview: Endpoints to list and manage officials, retrieve staff, work with group custom fields, and create/update students for registration workflows. These are central to roster management, eligibility enforcement, and downstream business processes (payments, compliance, scheduling).

Notes:

Scopes vary by operation (commonly Scheduling for officials/staff, Registration for student/profile operations, Eligibility for status lookups). We’ll annotate per endpoint when the OpenAPI spec is ingested.

Treat HTTP 404 as “no records for your filter” (expected when polling by lastModifiedDate).

1) GET `/api/CustomField/GetGroupCustomFields`

Scope: Registration (read custom field definitions used with officials/students/staff in a group)
Purpose: Retrieve custom field definitions configured for a group—use to validate inbound data and render dynamic forms.
Common params: groupId (if supported in your spec)
Sample response (placeholder fields):

[
  { "name": "CertificationNumber", "type": "string", "required": false },
  { "name": "BackgroundCheckDate", "type": "date", "required": true }
]

cURL

curl "https://partner.arbitersports.com/api/CustomField/GetGroupCustomFields" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
r = requests.get("https://partner.arbitersports.com/api/CustomField/GetGroupCustomFields",
                 headers={"Authorization": f"Bearer {TOKEN}"})

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/CustomField/GetGroupCustomFields", {
  headers: { Authorization: Bearer [token] }
});
console.log(res.status === 404 ? "No custom fields." : await res.json());

2) GET `/api/Official/GetOfficials`

Scope: Registration
Purpose: List officials (roster). Use to populate assignment UIs, confirm availability/eligibility, and route communications.
Common params:
- (Typically none; some deployments may support filters such as groupId, lastModifiedDate for incremental pulls—confirm in spec.)
Sample response (placeholder fields):

[
  {
    "officialId": "OFF-2001",
    "firstName": "Jordan",
    "lastName": "Patel",
    "email": "jordan.patel@example.org",
    "phone": "+1-801-555-0100",
    "eligibilityStatus": "Eligible",
    "crews": ["CREW-33"],
    "lastModifiedDate": "2025-11-19T18:05:00Z"
  }
]

cURL

curl "https://partner.arbitersports.com/api/Official/GetOfficials" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
r = requests.get("https://partner.arbitersports.com/api/Official/GetOfficials",
                 headers={"Authorization": f"Bearer {TOKEN}"})
print("No officials." if r.status_code == 404 else r.json())

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Official/GetOfficials", {
  headers: { Authorization: Bearer [token] }
});
console.log(res.status === 404 ? "No officials." : await res.json());

3) POST `/api/Official/SaveOfficial`

Scope: Registration
Purpose: Create or update an official’s profile (contact info, identifiers, etc.). Use stable officialId for idempotent upserts.
Request body (example):

{
  "officialId": "OFF-2001",
  "firstName": "Jordan",
  "lastName": "Patel",
  "email": "jordan.patel@example.org",
  "phone": "+1-801-555-0100"
}

cURL

curl -X POST "https://partner.arbitersports.com/api/Official/SaveOfficial" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{
        "officialId": "OFF-2001",
        "firstName": "Jordan",
        "lastName": "Patel",
        "email": "jordan.patel@example.org",
        "phone": "+1-801-555-0100"
      }'

Python

import requests, json
payload = {
  "officialId": "OFF-2001",
  "firstName": "Jordan",
  "lastName": "Patel",
  "email": "jordan.patel@example.org",
  "phone": "+1-801-555-0100"
}
r = requests.post("https://partner.arbitersports.com/api/Official/SaveOfficial",
                  headers={"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"},
                  data=json.dumps(payload))
print(r.json() if r.status_code < 400 else r.text)

JavaScript

const payload = {
  officialId: "OFF-2001",
  firstName: "Jordan",
  lastName: "Patel",
  email: "jordan.patel@example.org",
  phone: "+1-801-555-0100"
};
const res = await fetch("https://partner.arbitersports.com/api/Official/SaveOfficial", {
  method: "POST",
  headers: { Authorization: Bearer ${TOKEN}, "Content-Type": "application/json" },
  body: JSON.stringify(payload)
});
console.log(await res.json());

4) POST `/api/Official/RemoveOfficial`

Scope: Registration
Purpose: Remove (deactivate) an official record. Use with care—capture audit context if required (who/when/why).
Request body (example):

{ "officialId": "OFF-2001", "reason": "Retired" }

cURL

curl -X POST "https://partner.arbitersports.com/api/Official/RemoveOfficial" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{ "officialId": "OFF-2001", "reason": "Retired" }'

Python

import requests, json
payload = { "officialId": "OFF-2001", "reason": "Retired" }
r = requests.post("https://partner.arbitersports.com/api/Official/RemoveOfficial",
                  headers={"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"},
                  data=json.dumps(payload))
print(r.json() if r.status_code < 400 else r.text)

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Official/RemoveOfficial", {
  method: "POST",
  headers: { Authorization: Bearer [token], "Content-Type": "application/json" },
  body: JSON.stringify({ officialId: "OFF-2001", reason: "Retired" })
});
console.log(await res.json());

5) POST `/api/Official/CustomField`

Scope: Registration
Purpose: Update custom field values for a specific official (e.g., certifications, gear sizes). Use the field definitions from GetGroupCustomFields.
Request body (example):

{
  "officialId": "OFF-2001",
  "fields": [
    { "name": "CertificationNumber", "value": "C-124589" },
    { "name": "BackgroundCheckDate", "value": "2025-10-15" }
  ]
}

cURL

curl -X POST "https://partner.arbitersports.com/api/Official/CustomField" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{
        "officialId": "OFF-2001",
        "fields": [
          { "name": "CertificationNumber", "value": "C-124589" },
          { "name": "BackgroundCheckDate", "value": "2025-10-15" }
        ]

Python

import requests, json
payload = {
  "officialId": "OFF-2001",
  "fields": [
    { "name": "CertificationNumber", "value": "C-124589" },
    { "name": "BackgroundCheckDate", "value": "2025-10-15" }
  ]
}
r = requests.post("https://partner.arbitersports.com/api/Official/CustomField",
                  headers={"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"},
                  data=json.dumps(payload))
print(r.json() if r.status_code < 400 else r.text)

JavaScript

const payload = {
  officialId: "OFF-2001",
  fields: [
    { name: "CertificationNumber", value: "C-124589" },
    { name: "BackgroundCheckDate", value: "2025-10-15" }
  ]
};
const res = await fetch("https://partner.arbitersports.com/api/Official/CustomField", {
  method: "POST",
  headers: { Authorization: Bearer ${TOKEN}, "Content-Type": "application/json" },
  body: JSON.stringify(payload)
});
console.log(await res.json());

6) GET `/api/Official/details`

Scope: Registration
Purpose: Retrieve detailed profile data for a specific official (contact info, roles, crews, eligibility summary).
Common params: officialId
Sample response (placeholder fields):

{
  "officialId": "OFF-2001",
  "firstName": "Jordan",
  "lastName": "Patel",
  "email": "jordan.patel@example.org",
  "phone": "+1-801-555-0100",
  "crews": ["CREW-33"],
  "eligibility": { "tierId": "TIER-200", "status": "Eligible" },
  "lastModifiedDate": "2025-11-19T18:05:00Z"
}

cURL

curl -G "https://partner.arbitersports.com/api/Official/details" \
  -H "Authorization: Bearer $TOKEN" \

Python

import requests
r = requests.get("https://partner.arbitersports.com/api/Official/details",
                 headers={"Authorization": f"Bearer {TOKEN}"},
                 params={"officialId": "OFF-2001"})
print("Official not found." if r.status_code == 404 else r.json())

JavaScript

const url = new URL("https://partner.arbitersports.com/api/Official/details");
url.searchParams.set("officialId", "OFF-2001");
const res = await fetch(url, { headers: { Authorization: Bearer [token] }});
console.log(res.status === 404 ? "Official not found." : await res.json());

7) GET `/api/Staff/GetStaff`

Scope: Registration
Purpose: Retrieve staff (e.g., admins/coordinators) for allowed organizations—use to route communications and control panels.
Common params: (Typically none; confirm filters in spec.)
Sample response (placeholder fields):

[
  {
    "staffId": "STF-100",
    "firstName": "Taylor",
    "lastName": "Morgan",
    "email": "taylor.morgan@example.org",
    "role": "Assigning Coordinator",
    "lastModifiedDate": "2025-11-19T18:06:00Z"
  }
]

cURL

curl "https://partner.arbitersports.com/api/Staff/GetStaff" \
  -H "Authorization: Bearer $TOKEN"

Python

import requests
r = requests.get("https://partner.arbitersports.com/api/Staff/GetStaff",
                 headers={"Authorization": f"Bearer {TOKEN}"})
print("No staff." if r.status_code == 404 else r.json())

JavaScript

const res = await fetch("https://partner.arbitersports.com/api/Staff/GetStaff", {
  headers: { Authorization: Bearer [token] }
});
console.log(res.status === 404 ? "No staff." : await res.json());

8) POST `/api/Student/{schoolId}` & 9) PUT `/api/Student/{schoolId}`

Scope: Registration
Purpose: Create (POST) or update (PUT) student records for a school, supporting registration and compliance workflows. Use stable student identifiers for idempotent upserts.
Path param: schoolId
Request body (example):

{
  "studentId": "STU-9001",
  "firstName": "Ava",
  "lastName": "Nguyen",
  "graduationYear": 2027,
  "email": "ava.nguyen@example.org"
}

cURL (create)

curl -X POST "https://partner.arbitersports.com/api/Student/SCH-567" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{ "studentId": "STU-9001", "firstName": "Ava", "lastName": "Nguyen", "graduationYear": 2027 }'

cURL (update)

curl -X PUT "https://partner.arbitersports.com/api/Student/SCH-567" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{ "studentId": "STU-9001", "graduationYear": 2028 }'

Python (create)

import requests, json
payload = { "studentId": "STU-9001", "firstName": "Ava", "lastName": "Nguyen", "graduationYear": 2027 }
r = requests.post("https://partner.arbitersports.com/api/Student/SCH-567",
                  headers={"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"},
                  data=json.dumps(payload))
print(r.json() if r.status_code < 400 else r.text)

JavaScript (update)

const res = await fetch("https://partner.arbitersports.com/api/Student/SCH-567", {
  method: "PUT",
  headers: { Authorization: Bearer [token], "Content-Type": "application/json" },
  body: JSON.stringify({ studentId: "STU-9001", graduationYear: 2028 })
});
console.log(await res.json());

Usage Tips (business outcomes)

Assignment readiness: Combine Official details + Eligibility (and EligibilityTier) to ensure only compliant officials are assigned.
Custom fields as extensions: Keep schemas stable; store partner‑specific metadata in CustomField rather than creating new fixed columns.
Student data hygiene: When integrating with SIS, map students to canonical IDs and use PUT for idempotent updates; capture change logs for audits.
Polling: If you support lastModifiedDate on officials/staff/student endpoints, treat 404 as “no data for window” and continue your cadence.

5) Field‑Level JSON (Reference Models)

Note: The exact field names/types are defined in the OpenAPI JSON (/swagger/v1/swagger.json). The tables below capture common, production‑grade shapes based on endpoint semantics. Replace/confirm as you paste canonical details from your spec.

Game (GET `/api/Game/GetGames`, `/GetGamesByUniqueGameIds`)

Field	Type	Nullable	Description
uniqueGameId	string	false	Stable identifier across pulls; use for de‑duplication and reconciliation.
gameNumber	string	true	Per‑account ID; user‑configurable number for a game.
sportId	string	false	Sport taxonomy ID (see `GetGenericSports`).
levelId	string	false	Level taxonomy ID (see `GetLevels`).
homeTeamId	string	false	Home team ID.
awayTeamId	string	false	Away team ID.
siteId	string	false	Venue/site ID (see `Site` endpoints).
startDateTime	string	false	ISO‑8601 start time in UTC.
status	string	false	e.g., Scheduled, Completed, Canceled.
lastModifiedDate	string	false	ISO‑8601 timestamp for incremental polling window.

Assignment (GET `/api/Assignment/*`)

Field	Type	Nullable	Description
assignmentId	string	false	Unique assignment ID.
uniqueGameId	string	false	Link to Game.
officialId	string	false	Assigned official/worker identifier.
role	string	false	Role (Referee/Umpire/etc.).
status	string	false	Assigned/Pending/Removed/etc.
lastModifiedDate	string	false	For incremental polling.

Official (GET/POST `/api/Official/*`)

Field	Type	Nullable	Description
officialId	string	false	Unique identifier.
firstName	string	false	Given name.
lastName	string	false	Family name.
email	string	true	Contact email.
phone	string	true	Contact phone.
eligibilityStatus	string	true	Current eligibility.
crews	array	true	Crew identifiers.

Team (GET `/api/Team/*`)

Field	Type	Nullable	Description
teamId	string	false	Unique team identifier.
name	string	false	Team display name.
schoolId	string	true	Associated school.
sportId	string	false	Sport taxonomy ID.
levelId	string	false	Level taxonomy ID.
roster	array	true	Player objects (id, name, #).

Eligibility / Tier

Field	Type	Nullable	Description
userId	string	false	User/official/student identifier.
tierId	string	false	Eligibility tier identifier.
status	string	false	Eligible/Ineligible/Completed/etc.
lastModifiedDate	string	true	For incremental polling.

Site / Level / Sport

Field	Type	Nullable	Description
siteId	string	false	Venue identifier.
typeId	string	true	Site type/subtype IDs.
levelId	string	false	Level identifier.
sportId	string	false	Sport identifier/code.

You can substitute exact types (e.g., GUID vs. string) after pasting canonical schema definitions from the OpenAPI JSON. The public Swagger UI confirms the endpoint list; the JSON file provides the per‑field contracts.

Search

Arbiter Partner API – Comprehensive Reference

Overview

Getting started

Becoming a partner

API Explorer

Environments

Scopes

Rate Limit & Pagination

Table of Contents

1) Authentication (OAuth2 – Client Credentials)

2) Polling Strategy (near‑realtime via lastModifiedDate)

3) Error Handling & 404 Semantics

4) Endpoint Catalog & Examples

Legend

A. Assignment

B. CustomField

C. Eligibility

D. EligibilityTier

1) GET /api/eligibility/tier/eligibilitytiers

2) POST /api/eligibility/tier/markcomplete

3) POST /api/eligibility/tier/unenrolluser

4) GET /api/eligibility/tier/officials

Usage Tips (business outcomes)

F. Organization

1) GET /api/Group

2) GET /api/Group/alignment

3) GET /api/School/GetAllSchools

4) GET /api/School/GetPartnerIdsForSchools

Organization Data Usage Tips

G. Resources

1) GET /api/Official/GetCrews

2) GET /api/Sport/GetGenericSports

3) GET /api/Team/GetTeams

4) GET /api/Team/GetTeamWithRosters

Resource Usage Tips (business outcomes)

H. Schedule

1) GET /api/Event/GetEvents

2) GET /api/Event/GetAssociationEvents

3) GET /api/Game/GetGamesByUniqueGameIds

4) GET /api/Game/GetGames

5) GET /api/Game/GameTypes

6) GET /api/Game/DeletedGames

7) GET /api/Game/GetTournaments

8) GET /api/Game/GetGameHistory

9) GET /api/Game/GetGameTeamHistory

10) GET /api/Official/OfficialBlock

I. Status

1) GET /api/Level/GetLevels

2) GET /api/Maint/AppVersion & HEAD /api/Maint/AppVersion

3) GET /api/Site/SiteTypes

4) GET /api/Site/SubSiteTypes

5) GET /api/Site

Usage Tips (business outcomes)

J. User / Officials / Staff / Students

1) GET /api/CustomField/GetGroupCustomFields

2) GET /api/Official/GetOfficials

3) POST /api/Official/SaveOfficial

4) POST /api/Official/RemoveOfficial

5) POST /api/Official/CustomField

6) GET /api/Official/details

7) GET /api/Staff/GetStaff

8) POST /api/Student/{schoolId} & 9) PUT /api/Student/{schoolId}

Usage Tips (business outcomes)

5) Field‑Level JSON (Reference Models)

Game (GET /api/Game/GetGames, /GetGamesByUniqueGameIds)

Assignment (GET /api/Assignment/*)

Official (GET/POST /api/Official/*)

Team (GET /api/Team/*)

Eligibility / Tier

Site / Level / Sport

Was this article helpful?

Comments

Categories

2) Polling Strategy (near‑realtime via `lastModifiedDate`)

1) GET `/api/eligibility/tier/eligibilitytiers`

2) POST `/api/eligibility/tier/markcomplete`

3) POST `/api/eligibility/tier/unenrolluser`

4) GET `/api/eligibility/tier/officials`

1) GET `/api/Group`

2) GET `/api/Group/alignment`

3) GET `/api/School/GetAllSchools`

4) GET `/api/School/GetPartnerIdsForSchools`

1) GET `/api/Official/GetCrews`

2) GET `/api/Sport/GetGenericSports`

3) GET `/api/Team/GetTeams`

4) GET `/api/Team/GetTeamWithRosters`

1) GET `/api/Event/GetEvents`

2) GET `/api/Event/GetAssociationEvents`

3) GET `/api/Game/GetGamesByUniqueGameIds`

4) GET `/api/Game/GetGames`

5) GET `/api/Game/GameTypes`

6) GET `/api/Game/DeletedGames`

7) GET `/api/Game/GetTournaments`

8) GET `/api/Game/GetGameHistory`

9) GET `/api/Game/GetGameTeamHistory`

10) GET `/api/Official/OfficialBlock`

1) GET `/api/Level/GetLevels`

2) GET `/api/Maint/AppVersion` & HEAD `/api/Maint/AppVersion`

3) GET `/api/Site/SiteTypes`

4) GET `/api/Site/SubSiteTypes`

5) GET `/api/Site`

1) GET `/api/CustomField/GetGroupCustomFields`

2) GET `/api/Official/GetOfficials`

3) POST `/api/Official/SaveOfficial`

4) POST `/api/Official/RemoveOfficial`

5) POST `/api/Official/CustomField`

6) GET `/api/Official/details`

7) GET `/api/Staff/GetStaff`

8) POST `/api/Student/{schoolId}` & 9) PUT `/api/Student/{schoolId}`

Game (GET `/api/Game/GetGames`, `/GetGamesByUniqueGameIds`)

Assignment (GET `/api/Assignment/*`)

Official (GET/POST `/api/Official/*`)

Team (GET `/api/Team/*`)