How to Integrate Retool with Schoology

Before creating the Retool resource, obtain your Schoology API credentials. In Schoology, navigate to your Account Settings → API and click Generate API Credentials. This gives you a consumer key and consumer secret. If you do not see an API section, contact your Schoology district administrator to enable API access for your account. In Retool, go to the Resources tab and click Add Resource. Select REST API from the resource type list. Name the resource 'Schoology API'. In the Base URL field, enter https://api.schoology.com. All Schoology API v1 endpoints follow the pattern /v1/{resource} which will be appended to this base URL. Schoolygy uses OAuth 1.0a authentication, which signs each request with your consumer key and secret. In Retool's REST API resource, set the Authentication type to Basic Auth as a starting point, then switch to Custom Headers to properly implement OAuth 1.0a. Add the following header: - Authorization: OAuth realm='Schoology API', oauth_consumer_key='{{ retoolContext.configVars.SCHOOLOGY_CONSUMER_KEY }}', oauth_signature_method='HMAC-SHA1', oauth_timestamp='', oauth_nonce='', oauth_version='1.0', oauth_signature='' For production use, implement the full OAuth 1.0a signature via a Retool Workflow or JavaScript query that generates the Authorization header dynamically. Store your consumer key in Settings → Configuration Variables as SCHOOLOGY_CONSUMER_KEY and the consumer secret as SCHOOLOGY_CONSUMER_SECRET (both marked as Secret). Save the resource configuration.

1// JavaScript query — generate OAuth 1.0a Authorization header for Schoology
2// Run this query before your API calls to get a fresh signed header
3const consumerKey = retoolContext.configVars.SCHOOLOGY_CONSUMER_KEY;
4const consumerSecret = retoolContext.configVars.SCHOOLOGY_CONSUMER_SECRET;
5const method = 'GET';
6const url = 'https://api.schoology.com/v1/users';
7
8// Generate OAuth parameters
9const timestamp = Math.floor(Date.now() / 1000).toString();
10const nonce = Math.random().toString(36).substring(2) + Math.random().toString(36).substring(2);
11
12// For simple read-only operations, Schoology also accepts two-legged OAuth
13// where the Authorization header is built with consumer key only (no token)
14const authHeader = `OAuth realm="Schoology API",` +
15  `oauth_consumer_key="${consumerKey}",` +
16  `oauth_signature_method="PLAINTEXT",` +
17  `oauth_timestamp="${timestamp}",` +
18  `oauth_nonce="${nonce}",` +
19  `oauth_version="1.0",` +
20  `oauth_signature="${consumerSecret}%26"`;
21
22return { authorization: authHeader };

Create queries to retrieve the core Schoology data your dashboard needs. Start with courses and users, which are the foundation of most administrative reports. Create a query named getCourses: - Method: GET - Path: /v1/courses - Headers: Authorization = {{ generateOAuthHeader.data.authorization }} This returns courses across your Schoology account. Each course object includes an id, title, course_code, description, and building_id (school identifier). Add a URL parameter school_id to filter by a specific school if your district has multiple buildings. Create a query named getCourseEnrollments: - Method: GET - Path: /v1/courses/{{ dropdown_course.value }}/sections - Headers: Authorization = {{ generateOAuthHeader.data.authorization }} This retrieves all sections of a selected course, including enrollment counts. To get the actual list of enrolled users in a section, create getEnrolledStudents: - Method: GET - Path: /v1/sections/{{ table_sections.selectedRow.id }}/enrollments - Headers: Authorization = {{ generateOAuthHeader.data.authorization }} Bind getCourses results to a Select component named dropdown_course. When a course is selected, getCourseEnrollments runs to populate a sections table. Selecting a section row triggers getEnrolledStudents to show the student roster. Schoolygy enrollment responses include role (admin, teacher, student) and status (active, inactive) fields — filter to status=1 (active) and role=student to see only currently enrolled students.

1// JavaScript transformer — format enrollment list for student roster table
2const enrollments = (data.enrollment || []);
3return enrollments
4  .filter(e => e.status === 1 && e.admin === 0)  // active students only
5  .map(enrollment => ({
6    uid: enrollment.uid,
7    name: `${enrollment.name_first || ''} ${enrollment.name_last || ''}`.trim(),
8    email: enrollment.primary_email || 'N/A',
9    grade_level: enrollment.grad_year || 'N/A',
10    enrollment_status: enrollment.status === 1 ? 'Active' : 'Inactive',
11    enrollment_date: enrollment.created
12      ? new Date(enrollment.created * 1000).toLocaleDateString()
13      : 'N/A'
14  }))
15  .sort((a, b) => a.name.localeCompare(b.name));

Create queries to retrieve grade data for students in a selected course section. Schoology's grades API provides both overall course grades and individual assignment scores. Create a query named getSectionGrades: - Method: GET - Path: /v1/sections/{{ table_sections.selectedRow.id }}/grades - Headers: Authorization = {{ generateOAuthHeader.data.authorization }} This returns grade data for all students in the section. The response includes an array of student grade objects with uid, grade, comment, and a grades array of individual assignment scores. Create a query named getSectionAssignments: - Method: GET - Path: /v1/sections/{{ table_sections.selectedRow.id }}/assignments - Headers: Authorization = {{ generateOAuthHeader.data.authorization }} This retrieves all assignments in the section with due dates, point values, and categories. Combine getSectionGrades and getSectionAssignments in a JavaScript query to calculate completion rates: Bind the merged data to a Table component with columns for student name, current grade (formatted as a letter grade), assignments completed, assignments missing, and completion rate. Apply conditional row formatting to highlight students below 70% grade in red and students with more than 3 missing assignments in orange. For individual student drilldown, create getStudentGradeDetail: - Method: GET - Path: /v1/users/{{ table_students.selectedRow.uid }}/grades - URL parameter: section_id = {{ table_sections.selectedRow.id }} This shows the complete grade breakdown for a single student across all assignments in the section.

1// JavaScript query — merge grades with assignment data to calculate completion
2const grades = (getSectionGrades.data?.grades?.grade || []);
3const assignments = (getSectionAssignments.data?.assignment || []);
4const totalAssignments = assignments.length;
5
6return grades.map(studentGrade => {
7  const assignmentScores = studentGrade.grades?.grade || [];
8  const completed = assignmentScores.filter(
9    g => g.grade !== null && g.grade !== undefined && g.grade !== ''
10  ).length;
11  const missing = totalAssignments - completed;
12  const overallGrade = parseFloat(studentGrade.grade);
13
14  return {
15    uid: studentGrade.uid,
16    overall_grade: isNaN(overallGrade) ? 'N/A' : `${overallGrade.toFixed(1)}%`,
17    letter_grade: overallGrade >= 90 ? 'A'
18      : overallGrade >= 80 ? 'B'
19      : overallGrade >= 70 ? 'C'
20      : overallGrade >= 60 ? 'D' : 'F',
21    assignments_completed: completed,
22    assignments_missing: missing,
23    completion_rate: totalAssignments > 0
24      ? `${((completed / totalAssignments) * 100).toFixed(0)}%`
25      : 'N/A',
26    at_risk: overallGrade < 70 || missing > 3
27  };
28});

Create a performance comparison view that lets curriculum directors compare grade distributions across multiple sections of the same course. This is one of the most valuable uses of Retool for K-12 administrators because Schoology's built-in UI shows one section at a time. Create a JavaScript query named aggregateSectionPerformance that runs after fetching grades for multiple sections: In your Retool app layout, add a Multi-Select component named multiSelect_sections to let users choose which sections to compare. Set its options bound to {{ getCourseEnrollments.data.section.map(s => ({ label: s.section_title, value: s.id })) }}. Add a Chart component configured as a grouped bar chart with sections on the x-axis and average grade on the y-axis. Below the chart, add a Table showing the summary statistics per section: section name, teacher name, enrolled count, average grade, passing rate (students above 70%), and A-rate (students above 90%). For the teacher performance view, add a text component that calculates which section has the highest average grade and displays it as a highlighted best practice: 'Section {{ bestPerformingSection.name }} led by {{ bestPerformingSection.teacher }} has the highest average grade of {{ bestPerformingSection.avg }}%'. This cross-section view is the core value proposition of the Retool-Schoology integration for district administrators and curriculum directors who need to make data-driven decisions about instructional support.

1// JavaScript query — aggregate performance statistics across multiple sections
2// Assumes sectionGradesData is an array of { sectionId, sectionTitle, teacher, grades[] }
3const sectionData = sectionGradesData || [];
4
5return sectionData.map(section => {
6  const grades = (section.grades || []).map(g => parseFloat(g.grade)).filter(g => !isNaN(g));
7  const avg = grades.length > 0
8    ? grades.reduce((sum, g) => sum + g, 0) / grades.length
9    : 0;
10  const passing = grades.filter(g => g >= 70).length;
11  const aGrade = grades.filter(g => g >= 90).length;
12
13  return {
14    section_id: section.sectionId,
15    section_title: section.sectionTitle || 'Unknown Section',
16    teacher: section.teacher || 'Unknown',
17    enrolled: grades.length,
18    average_grade: avg.toFixed(1),
19    passing_count: passing,
20    passing_rate: grades.length > 0
21      ? `${((passing / grades.length) * 100).toFixed(0)}%`
22      : 'N/A',
23    a_rate: grades.length > 0
24      ? `${((aGrade / grades.length) * 100).toFixed(0)}%`
25      : 'N/A'
26  };
27}).sort((a, b) => parseFloat(b.average_grade) - parseFloat(a.average_grade));

Build a student search panel that gives counselors and administrators the ability to look up any student across all courses and identify at-risk indicators. This requires combining user lookup with cross-course grade queries. Create a query named searchUsers: - Method: GET - Path: /v1/users - URL parameter: school_uid = {{ textInput_studentSearch.value }} (for searching by student ID) - Headers: Authorization = {{ generateOAuthHeader.data.authorization }} For name-based search, Schoology supports a name_first and name_last parameter. Add these as conditional URL parameters. Once a student is selected from the search results, create getStudentCourses: - Method: GET - Path: /v1/users/{{ selectedStudent.uid }}/sections - Headers: Authorization = {{ generateOAuthHeader.data.authorization }} This retrieves all course sections the student is currently enrolled in. For each section, fetch their grade using the grades endpoint. Combine the results in a JavaScript query that flags: - Any course where grade is below 70% - Any course where grade has dropped more than 10 points in the last two weeks - Any section with more than 3 overdue assignments Display the at-risk summary at the top of the student profile panel using Callout or Alert components, then show the full course list below. For complex multi-school district implementations with thousands of students, RapidDev's team can help architect a caching layer using Retool Database that pre-computes at-risk indicators nightly so the student lookup panel loads instantly.

1// JavaScript query — identify at-risk indicators across student's enrolled courses
2const enrolledCourses = (getStudentCourses.data?.section || []);
3const gradeData = studentGradesByCourse || {}; // Object keyed by section ID
4
5const coursesSummary = enrolledCourses.map(section => {
6  const grades = gradeData[section.id] || {};
7  const currentGrade = parseFloat(grades.grade) || null;
8  const missingCount = parseInt(grades.missing_assignments) || 0;
9
10  return {
11    section_id: section.id,
12    course_title: section.course_title || 'Unknown Course',
13    section_title: section.section_title || '',
14    teacher: section.teacher_name || 'Unknown',
15    current_grade: currentGrade !== null ? `${currentGrade.toFixed(1)}%` : 'No grades',
16    letter_grade: currentGrade >= 90 ? 'A' : currentGrade >= 80 ? 'B'
17      : currentGrade >= 70 ? 'C' : currentGrade >= 60 ? 'D' : 'F',
18    missing_assignments: missingCount,
19    at_risk_grade: currentGrade !== null && currentGrade < 70,
20    at_risk_missing: missingCount > 3,
21    risk_level: (currentGrade < 70 && missingCount > 3) ? 'HIGH'
22      : (currentGrade < 70 || missingCount > 3) ? 'MEDIUM' : 'LOW'
23  };
24});
25
26return {
27  courses: coursesSummary,
28  high_risk_count: coursesSummary.filter(c => c.risk_level === 'HIGH').length,
29  medium_risk_count: coursesSummary.filter(c => c.risk_level === 'MEDIUM').length
30};