How to Integrate Retool with Blackboard

Blackboard REST API access requires a registered application — this is an enterprise configuration step that requires System Administrator access to the Blackboard Learn instance. Log into your Blackboard Learn instance as a System Administrator. Navigate to the Admin Panel (typically at /webapps/blackboard/admin/admin_main.jsp or via the System Admin tab). Look for the Integration section and click REST API Integrations. Click Create Integration. Fill in the registration form: - Application Name: 'Retool Operations Dashboard' - Learn User: associate this integration with a dedicated service account user (create one specifically for API access — do not use a personal admin account) - End User Access: 'Yes' for most management operations (allows the integration to act with the permissions of the authenticated user) - Authorized To Act As User: leave as 'No' unless you need full user impersonation - Application Description: 'Retool internal dashboard for LMS operations' Click Submit. The system displays the Application ID and the one-time Application Secret. Copy both values immediately — the Application Secret cannot be retrieved again after this screen. For institutions using Anthology's hosted Blackboard service, you may also register through the Anthology developer portal (developer.anthology.com) for sandbox or partner access. In production, the system administrator registration within the Learn instance is the standard path. Add the Application ID and Secret as secret Retool configuration variables: - BLACKBOARD_APP_ID: your Application ID - BLACKBOARD_APP_SECRET: your Application Secret - BLACKBOARD_BASE_URL: your Learn instance URL (e.g., https://learn.youruniversity.edu)

Blackboard's OAuth 2.0 flow requires first obtaining a bearer token, then using it for all subsequent API calls. The token endpoint is at your Blackboard instance URL + /learn/api/public/v1/oauth2/token. Create a token request query first. In your Retool app, create a new REST API Resource for the token endpoint: - Name: 'Blackboard Auth' - Base URL: {{ retoolContext.configVars.BLACKBOARD_BASE_URL }} - Authentication: Basic Auth - Username: {{ retoolContext.configVars.BLACKBOARD_APP_ID }} - Password: {{ retoolContext.configVars.BLACKBOARD_APP_SECRET }} Save this resource. Create a query using this resource: - Method: POST - Path: /learn/api/public/v1/oauth2/token - Body type: Form (application/x-www-form-urlencoded) - Body parameter: grant_type = client_credentials This returns an access_token and expires_in (seconds). Now create the main API resource: - Name: 'Blackboard Learn API' - Base URL: {{ retoolContext.configVars.BLACKBOARD_BASE_URL }} - Authentication: Bearer Token - Token: {{ blackboardAuthQuery.data.access_token }} Set the auth query to run on page load. All subsequent Blackboard API queries should use the 'Blackboard Learn API' resource. The token expires after the period specified in expires_in (typically 3600 seconds / 1 hour) — add a manual 'Refresh Token' button that re-triggers blackboardAuthQuery.

Create a query to list courses in Blackboard. In your Retool app, go to the Code panel and create a new query. Select the 'Blackboard Learn API' resource. Configure the course list query: - Method: GET - Path: /learn/api/public/v3/courses - URL parameters: - fields: id,courseId,name,status,ultraStatus,enrollment,term (select specific fields to reduce response size) - availability.available: Yes (filter to available courses; remove for all courses) - limit: 100 - offset: {{ pagination.offset || 0 }} Blackboard's response wraps courses in a results array with a paging object for offset-based pagination. Add a JavaScript transformer to flatten the course objects and format enrollment capacity data. Create an enrollment/membership query for a selected course: - Method: GET - Path: /learn/api/public/v1/courses/{{ courseTable.selectedRow.id }}/users - URL parameters: - fields: userId,courseRoleId,availability,user.userName,user.name,user.externalId,created - limit: 200 This returns the course roster with roles (Student, Instructor, TeachingAssistant, CourseAdmin). Add a transformer to display full names and role labels. Drag two Table components: one for courses, one for the selected course's enrollment roster. Add filters above the course table for status and a text search for course name.

1// Transformer for Blackboard v3 courses response
2// data.results is the array of course objects
3const courses = data.results || [];
4return courses.map(course => {
5  const enrollment = course.enrollment || {};
6  const availability = course.availability || {};
7  return {
8    id: course.id,
9    course_id: course.courseId,
10    name: course.name || '',
11    status: availability.available || 'No',
12    ultra_status: course.ultraStatus || 'Classic',
13    enrollment_type: enrollment.type || '',
14    allow_guests: enrollment.allowGuests ? 'Yes' : 'No',
15    term_id: course.term?.id || '',
16    term_name: course.term?.name || '',
17    duration_start: course.duration?.start
18      ? new Date(course.duration.start).toLocaleDateString()
19      : '',
20    duration_end: course.duration?.end
21      ? new Date(course.duration.end).toLocaleDateString()
22      : ''
23  };
24});

Blackboard's Grade Journey API (v2 gradebook) provides access to grading columns and student grades. Create a query for gradebook columns: - Method: GET - Path: /learn/api/public/v2/courses/{{ courseTable.selectedRow.id }}/gradebook/columns - URL parameters: - limit: 200 - fields: id,name,displayName,score,grading,status,available And a query for grades in a specific column: - Method: GET - Path: /learn/api/public/v2/courses/{{ courseTable.selectedRow.id }}/gradebook/columns/{{ gradebookColumnsTable.selectedRow.id }}/users/{{ enrollmentsTable.selectedRow.userId }}/attempts - Or, for all students in a column: /learn/api/public/v2/courses/{{ courseTable.selectedRow.id }}/gradebook/columns/{{ gradebookColumnsTable.selectedRow.id }}/users Create a grading completion summary transformer that counts how many enrolled users have a grade entered in the selected column versus total enrolled: ```javascript const grades = data.results || []; const graded = grades.filter(g => g.status === 'Graded' || g.score !== null); const notGraded = grades.filter(g => g.status !== 'Graded' && g.score === null); return { total: grades.length, graded_count: graded.length, not_graded_count: notGraded.length, completion_pct: grades.length > 0 ? ((graded.length / grades.length) * 100).toFixed(1) : 0 }; ``` Display the grading summary in Statistics components above the grades table showing total, graded count, remaining, and completion percentage.

1// Transformer for Blackboard gradebook column grades response
2// data.results = array of grade objects per user
3const grades = data.results || [];
4return grades.map(grade => ({
5  user_id: grade.userId,
6  column_id: grade.columnId,
7  status: grade.status || 'Not Graded',
8  score: grade.score !== null && grade.score !== undefined ? grade.score : '',
9  text: grade.text || '',
10  feedback: grade.feedback || '',
11  instructor_feedback: grade.instructorFeedback?.text || '',
12  modified: grade.modified
13    ? new Date(grade.modified).toLocaleString()
14    : '',
15  graded: grade.score !== null && grade.score !== undefined ? 'Yes' : 'No'
16}));

Create user search and management queries. In the Code panel, create a user search query: - Method: GET - Path: /learn/api/public/v1/users - URL parameters: - userName: {{ userSearchInput.value }} - OR externalId: {{ userSearchInput.value }} (for searching by student ID) - fields: id,userName,name,externalId,availability,lastLogin,contact - limit: 25 For updating a user's availability (enable/disable account): - Method: PATCH - Path: /learn/api/public/v1/users/{{ usersTable.selectedRow.id }} - Body: { "availability": { "available": {{ userStatusToggle.value }} } } Organize the dashboard with a Tabs component: 1. Courses & Enrollment — the course table and roster panel from step 3 2. Grading Progress — the grading completion tracker from step 4 3. User Management — the user search and account management panel Add a dashboard summary header: - Total active courses (count from courses query) - Courses with incomplete grading (if tracking in internal database) - Users with disabled accounts (query users with availability.available=No) - Recent enrollment changes (query course memberships sorted by created date, last 24h) For complex Blackboard deployments requiring multi-term analytics, SIS integration, FERPA-compliant data handling, and automated reporting workflows, RapidDev's team can help architect and build your Retool solution.

1// Transformer for Blackboard user search results
2const users = data.results || [];
3return users.map(user => ({
4  id: user.id,
5  username: user.userName || '',
6  first_name: user.name?.given || '',
7  last_name: user.name?.family || '',
8  full_name: `${user.name?.given || ''} ${user.name?.family || ''}`.trim(),
9  student_id: user.externalId || user.studentId || '',
10  email: user.contact?.email || '',
11  status: user.availability?.available || 'No',
12  last_login: user.lastLogin
13    ? new Date(user.lastLogin).toLocaleString()
14    : 'Never',
15  user_type: user.systemRoleIds?.join(', ') || 'Student'
16}));