How to Integrate Retool with Udacity

Udacity's API access for enterprise customers is managed through their enterprise program. Log into the Udacity for Business admin portal at https://business.udacity.com and navigate to the Integrations or API Settings section. If API access is not visible, contact your Udacity customer success manager to request API credentials — Udacity typically provides enterprise API access as part of their Business or Enterprise tier plans. Once API access is enabled, Udacity will provide you with either an API key, a Bearer token, or OAuth 2.0 client credentials (client ID and client secret). Note the authentication method and the base URL for the API — Udacity's enterprise API typically uses a base URL such as https://api.udacity.com/api/v1/enterprise/ or a program-specific subdomain provided during onboarding. Also note the specific endpoints available for your account: common enterprise endpoints include /enrollments (list all learner enrollments), /learners/{id}/progress (progress for a specific learner), /cohorts (list active cohorts), and /completions (list completed Nanodegrees). The exact endpoint paths vary by Udacity's API version and your enterprise agreement, so consult your Udacity API documentation or request it from your account manager. Store your API token securely — you will add it to Retool as a configuration variable in the next step rather than entering it directly in the resource form.

Before creating the resource, store your Udacity API token securely in Retool's configuration variables. Navigate to Settings (gear icon in the Retool sidebar) → Configuration Variables. Click Add Variable, name it UDACITY_API_TOKEN, paste your API token as the value, and check the 'Secret' checkbox to restrict it to resource configurations only. Click Save. Now go to the Resources tab in the Retool sidebar and click Add Resource. In the resource type search, type 'REST' and select REST API. In the configuration form: - Base URL: enter your Udacity enterprise API base URL, for example https://api.udacity.com/api/v1/enterprise/ - Authentication: select 'Bearer Token' from the Authentication dropdown - Token: enter {{ retoolContext.configVars.UDACITY_API_TOKEN }} to reference your configuration variable rather than pasting the raw token In the Headers section, add a global header: 'Content-Type' with value 'application/json'. Some Udacity API versions also require an 'X-Organization-Id' header with your enterprise organization identifier — check your API documentation and add it here if needed. Give the resource a clear name like 'Udacity Enterprise API' and click Save Changes. The resource is now ready to use in your Retool queries.

Open or create a Retool app. In the Code panel at the bottom, click the + button to create a new query. Select your Udacity Enterprise API resource from the Resource dropdown. The query editor shows REST API mode with Method, Path, Query Params, Headers, and Body sections. For a basic enrollment list query: - Method: GET - Path: /enrollments (or the path provided in your Udacity API docs) - Query Parameters: add 'page' as {{ pagination.page || 1 }}, 'per_page' as {{ pagination.pageSize || 50 }}, and optionally 'program_key' as {{ programFilter.value }} to filter by a specific Nanodegree In the Advanced tab, add a JavaScript transformer to normalize the response into a flat array suitable for Retool's Table component: Name this query 'enrollmentsQuery' and set it to run automatically when inputs change (for pagination to work). Drag a Table component from the Component panel onto your canvas and set its Data to {{ enrollmentsQuery.data }}. Configure visible columns: learner_email, program_title, cohort_name, enrollment_date, progress_percentage, and status. Add a Select component above the table for filtering by program. Create a separate query to fetch available programs from /programs or /cohorts, and bind the Select component's options to that query's data. Reference the Select value in your enrollments query's program_key parameter.

1// JavaScript transformer to normalize Udacity enrollment API response
2const response = data;
3// Udacity API may wrap results in 'data', 'enrollments', or 'results' key
4const enrollments = response.enrollments || response.data || response.results || (Array.isArray(response) ? response : []);
5return enrollments.map(e => ({
6  learnerId: e.learner_id || e.id,
7  learnerEmail: e.learner_email || e.email || 'N/A',
8  programTitle: e.program_title || e.nanodegree_title || 'Unknown Program',
9  programKey: e.program_key || e.nanodegree_key || '',
10  cohortName: e.cohort_name || e.cohort_id || 'Default',
11  enrollmentDate: e.enrollment_date ? new Date(e.enrollment_date).toLocaleDateString() : 'N/A',
12  progressPercent: e.progress_percentage !== undefined ? Math.round(e.progress_percentage) + '%' : 'N/A',
13  status: e.status || e.state || 'enrolled',
14  lastActivity: e.last_activity_at ? new Date(e.last_activity_at).toLocaleDateString() : 'No activity'
15}));

To build aggregated cohort-level metrics — the core value of this dashboard — create a JavaScript query (not a resource query) that processes your enrollment data and computes completion statistics per cohort. In the Code panel, click + to create a new query. In the Resource dropdown, select 'Run JavaScript' (a built-in Retool query type). Write a transformer that aggregates the raw enrollment data from your enrollments query: This query will run automatically whenever enrollmentsQuery.data changes (set Run mode to 'Automatically run when inputs change', and reference enrollmentsQuery.data in the script). Bind a second Table or a Chart component to this aggregated data to show cohort-level metrics. For visualization, drag a Chart component (bar or column type) from the Component panel. Set its Chart data to {{ cohortMetricsQuery.data }}, X axis to 'cohortName', and Y axis to 'completionRate'. This gives L&D managers an at-a-glance view of which cohorts are performing well.

1// JavaScript query to aggregate enrollment data into cohort metrics
2const enrollments = enrollmentsQuery.data || [];
3
4// Group by cohort
5const cohortMap = {};
6enrollments.forEach(e => {
7  const key = e.cohortName || 'Unassigned';
8  if (!cohortMap[key]) {
9    cohortMap[key] = {
10      cohortName: key,
11      programTitle: e.programTitle,
12      total: 0,
13      completed: 0,
14      inProgress: 0,
15      notStarted: 0,
16      totalProgress: 0
17    };
18  }
19  cohortMap[key].total++;
20  cohortMap[key].totalProgress += parseFloat(e.progressPercent) || 0;
21  if (e.status === 'completed' || e.progressPercent === '100%') {
22    cohortMap[key].completed++;
23  } else if (e.status === 'enrolled' || parseFloat(e.progressPercent) > 0) {
24    cohortMap[key].inProgress++;
25  } else {
26    cohortMap[key].notStarted++;
27  }
28});
29
30return Object.values(cohortMap).map(c => ({
31  ...c,
32  completionRate: c.total > 0 ? Math.round((c.completed / c.total) * 100) + '%' : '0%',
33  avgProgress: c.total > 0 ? Math.round(c.totalProgress / c.total) + '%' : '0%'
34}));

To proactively identify and notify managers about at-risk learners — those who have been inactive for two weeks or more — create a Retool Workflow that runs weekly and sends alerts. Navigate to the Workflows section in Retool's home page sidebar (lightning bolt icon). Click New Workflow. On the workflow canvas, click Add Trigger and select Schedule. Set the schedule to run every Monday at 8:00 AM in your organization's timezone. Add a Resource Query block: select your Udacity Enterprise API resource, set Method to GET, and Path to /enrollments with parameters to fetch all active enrollments. Configure the block's timeout to 30 seconds for large enrollment lists. Add a Code block after the enrollment query. Write JavaScript to filter the enrollments for at-risk learners: those with last_activity_at more than 14 days ago and status not 'completed'. For each at-risk learner, collect their email, manager email (if available from your HR system), program title, and days since last activity. Add a second Resource Query block using your Slack resource (or email resource). Set it to post a summary message to your #learning-ops Slack channel listing the at-risk learners with their programs and inactivity duration. Alternatively, use a Loop block to send individual Slack DMs or emails to each learner's manager. Click Publish Release to activate the workflow. The schedule trigger will fire every Monday morning, check Udacity progress data, and send alerts for any at-risk learners.

1// Code block: filter at-risk learners from Udacity enrollment data
2const enrollments = block1.data.enrollments || block1.data || [];
3const TWO_WEEKS_MS = 14 * 24 * 60 * 60 * 1000;
4const now = new Date();
5
6const atRisk = enrollments.filter(e => {
7  if (e.status === 'completed') return false;
8  if (!e.last_activity_at) return true; // never logged in
9  const lastActivity = new Date(e.last_activity_at);
10  return (now - lastActivity) > TWO_WEEKS_MS;
11}).map(e => ({
12  email: e.learner_email || e.email,
13  program: e.program_title || e.nanodegree_title,
14  progress: e.progress_percentage || 0,
15  daysSinceActivity: e.last_activity_at
16    ? Math.floor((now - new Date(e.last_activity_at)) / (1000 * 60 * 60 * 24))
17    : 'never logged in'
18}));
19
20return atRisk;