How to Integrate Retool with Moodle

Moodle Web Services must be explicitly enabled and configured before generating tokens. Log into your Moodle site as an administrator and navigate to Site Administration → Server → Web services → Overview — this page shows all the setup steps in sequence. Step 1 — Enable Web Services: Go to Site Administration → Advanced features and tick 'Enable web services'. Save changes. Step 2 — Enable REST protocol: Go to Site Administration → Server → Web services → Manage protocols. Enable the REST protocol by clicking the eye icon next to REST. The REST protocol is what allows HTTP-based API calls from Retool. Step 3 — Create an external service: Go to Site Administration → Server → Web services → External services → Add. Name the service 'Retool Integration', tick 'Enabled' and 'Authorised users only', and save. You will be redirected to the service's Functions page — add the specific functions your dashboards need. For a comprehensive admin dashboard, add: core_user_get_users, core_course_get_courses, core_enrol_get_enrolled_users, gradereport_user_get_grade_items, mod_assign_get_assignments, mod_assign_get_submissions. Step 4 — Create a token: Go to Site Administration → Server → Web services → Manage tokens → Add a token. Select the user (create a dedicated service account user rather than using your admin account), select the 'Retool Integration' service, and optionally set an IP restriction. Click Save — the generated token is displayed once. Copy and store it securely. Note the exact functions you enabled in the service — only these functions will work with your token. If you encounter 'Access control exception' errors on a wsfunction, add that function to the service.

Moodle's Web Services API has a unique structure that differs from typical REST APIs. All requests go to a single endpoint URL, and the specific operation is determined by the 'wsfunction' URL parameter. The token is also passed as a URL parameter (wstoken) or in the request body. Navigate to the Resources tab in Retool and click Add Resource. Select REST API from the resource type list. Configure the resource: - Name: 'Moodle Web Services' - Base URL: https://your-moodle-site.com/webservice/rest/server.php For authentication, select No Authentication from the Auth dropdown — Moodle's token authentication uses a URL parameter rather than standard HTTP auth headers. Add default URL parameters that will be included in every request: - Key: wstoken, Value: YOUR_MOODLE_TOKEN (or better: {{ retoolContext.configVars.MOODLE_TOKEN }}) - Key: moodlewsrestformat, Value: json The moodlewsrestformat=json parameter tells Moodle to return JSON instead of XML — always include this. Click Save Changes. Store the Moodle token in a Retool Configuration Variable (Settings → Configuration Variables) named MOODLE_TOKEN, marked as secret. Update the wstoken default parameter to reference it: {{ retoolContext.configVars.MOODLE_TOKEN }}. Verify by creating a test query: - Method: GET - Path: (leave empty — the base URL is the full endpoint) - URL Parameters: wsfunction: core_webservice_get_site_info Run the query. A successful response returns your Moodle site's name, version, and information about the authenticated user, confirming the token and service configuration are correct.

The core_user_get_users Web Services function searches Moodle users by various criteria (name, email, username, etc.) and returns user profile data. This is the primary function for building user management panels. Create a new query using the Moodle Web Services resource: - Method: GET - Path: (empty) - URL Parameters: - wsfunction: core_user_get_users - criteria[0][key]: email (or 'fullname', 'username', 'id') - criteria[0][value]: {{ userSearchInput.value || '%' }} (% as wildcard for all users) Moodle's function parameter convention is unusual — array parameters are passed as criteria[0][key], criteria[0][value], criteria[1][key], criteria[1][value] for multiple criteria. In Retool's URL Parameters, each line is a separate key-value pair, so add them as individual lines. The response returns a users array with id, username, fullname, email, firstaccess, lastaccess, lastlogin, enrolled_courses, and other profile fields. Write a JavaScript transformer that formats the response, converts Unix timestamps to readable dates (Moodle uses Unix timestamps throughout its API), and adds a 'days since last login' computed field. Bind to a Table component with columns for full name, username, email, last login, and course count.

1// JavaScript transformer for Moodle core_user_get_users response
2const users = data?.users || [];
3
4function formatMoodleDate(unixTimestamp) {
5  if (!unixTimestamp) return 'Never';
6  return new Date(unixTimestamp * 1000).toLocaleDateString('en-US', {
7    year: 'numeric', month: 'short', day: 'numeric'
8  });
9}
10
11return users.map(user => {
12  const lastLoginTs = user.lastlogin || user.lastaccess || 0;
13  const daysSinceLogin = lastLoginTs > 0
14    ? Math.floor((Date.now() - lastLoginTs * 1000) / (1000 * 60 * 60 * 24))
15    : null;
16
17  return {
18    id: user.id,
19    username: user.username,
20    fullname: user.fullname || `${user.firstname || ''} ${user.lastname || ''}`.trim(),
21    email: user.email || '',
22    first_access: formatMoodleDate(user.firstaccess),
23    last_login: formatMoodleDate(lastLoginTs),
24    days_since_login: daysSinceLogin,
25    department: user.department || '',
26    institution: user.institution || '',
27    suspended: user.suspended ? 'Suspended' : 'Active'
28  };
29});

Build the course overview component of your LMS dashboard using core_course_get_courses to list courses and core_enrol_get_enrolled_users to get enrollment counts per course. Create a query for course data: - Method: GET - URL Parameters: - wsfunction: core_course_get_courses - options[ids][]: (leave empty to get all courses, or specify IDs) The response returns a courses array with id, fullname, shortname, categoryid, categoryname, startdate, enddate, timecreated, numsections, and a visible field. Write a transformer that formats the dates and filters out hidden courses. For enrollment counts, create a second query for a selected course: - wsfunction: core_enrol_get_enrolled_users - courseid: {{ coursesTable.selectedRow?.id }} - options[userfields][]: id,fullname,email This function returns all enrolled users for the selected course. Use a JavaScript transformer to count total enrollments and create a per-course enrollment summary. For completion data, use the completion_get_course_completion_status function (if installed and configured in Moodle) or the core_completion_get_activities_completion_status function to get per-user completion status for a course. Combine the enrollment count and completion count into a percentage. Display a courses Table with enrollment count and completion percentage, plus a Stat component row showing aggregate metrics: total active courses, total enrolled users across all courses, and average completion rate.

1// JavaScript transformer for Moodle course list response
2const courses = data || [];
3
4function formatMoodleDate(unixTs) {
5  if (!unixTs || unixTs === 0) return 'Not set';
6  return new Date(unixTs * 1000).toLocaleDateString('en-US', {
7    year: 'numeric', month: 'short', day: 'numeric'
8  });
9}
10
11return courses
12  .filter(course => course.visible === 1 && course.id !== 1) // exclude site home (id=1)
13  .map(course => ({
14    id: course.id,
15    fullname: course.fullname || 'Untitled Course',
16    shortname: course.shortname || '',
17    category: course.categoryname || 'Uncategorized',
18    start_date: formatMoodleDate(course.startdate),
19    end_date: formatMoodleDate(course.enddate),
20    sections: course.numsections || 0,
21    is_visible: course.visible === 1 ? 'Visible' : 'Hidden',
22    time_created: formatMoodleDate(course.timecreated)
23  }));

Grade data in Moodle is accessed through the gradereport_user_get_grade_items function, which returns grade items and scores for a specific user in a course. For an overview panel, you query grades per course and display aggregated statistics. Create a grade query: - Method: GET - URL Parameters: - wsfunction: gradereport_user_get_grade_items - courseid: {{ courseSelect.value }} - userid: {{ userSelect.value }} (optional — omit for course overview) The response returns a usergrades array, where each entry contains a userid, userfullname, and a gradeitems array with individual grade item names, grades, maximum grades, and percentage scores. For a course-level grade overview (not per-user), use mod_assign_get_submissions combined with mod_assign_get_grades to get assignment-level grade distributions. These require the assignment module to be enabled and configured. Write a transformer that calculates per-grade-item statistics: average grade, percentage of users who completed (received a grade), and minimum/maximum grades. Display a Table with grade item name, max possible, average achieved, and completion rate. For a combined view, add a search/select component for course and user, and display that specific user's grade report alongside the class average for context. Course administrators use this to quickly check individual student performance against class averages during advising sessions.

1// JavaScript transformer for Moodle gradereport response
2// Returns per-grade-item statistics for a course
3const userGrades = data?.usergrades || [];
4
5if (userGrades.length === 0) return [];
6
7// Collect all grade items from all users
8const gradeItemMap = {};
9
10userGrades.forEach(userEntry => {
11  const items = userEntry.gradeitems || [];
12  items.forEach(item => {
13    if (!gradeItemMap[item.id]) {
14      gradeItemMap[item.id] = {
15        id: item.id,
16        item_name: item.itemname || 'Course Total',
17        item_type: item.itemtype || 'category',
18        max_grade: parseFloat(item.grademax || 100),
19        grades: []
20      };
21    }
22    if (item.graderaw !== null && item.graderaw !== undefined) {
23      gradeItemMap[item.id].grades.push(parseFloat(item.graderaw));
24    }
25  });
26});
27
28return Object.values(gradeItemMap)
29  .filter(item => item.item_type === 'mod' || item.item_type === 'category')
30  .map(item => {
31    const grades = item.grades.filter(g => !isNaN(g));
32    const avg = grades.length > 0
33      ? grades.reduce((s, g) => s + g, 0) / grades.length
34      : null;
35    return {
36      item_name: item.item_name,
37      max_grade: item.max_grade,
38      graded_count: grades.length,
39      average_grade: avg !== null ? avg.toFixed(1) : 'N/A',
40      average_percent: avg !== null && item.max_grade > 0
41        ? ((avg / item.max_grade) * 100).toFixed(0) + '%' : 'N/A',
42      completion_rate: userGrades.length > 0
43        ? ((grades.length / userGrades.length) * 100).toFixed(0) + '%' : '0%'
44    };
45  });