Coursera

Before configuring anything in Bubble, confirm your organization has Partner API access. The clearest indicator: your Coursera account manager should have provided a `clientId` and `clientSecret`. If you only have a standard Coursera for Business admin login without API credentials, contact your Coursera account manager specifically to request Partner API access as part of your enterprise agreement. If you do not yet have API credentials, skip to Step 6 (CSV Import Alternative) now — it covers the data import path that works for all Coursera for Business subscribers without API credentials. **Set up the Config Data Type in Bubble:** Go to Data tab → Create a new Data Type: **Config**. Add these fields: - `coursera_client_id` (text) - `coursera_client_secret` (text) — marked sensitive - `coursera_access_token` (text) — will be populated by the refresh workflow - `coursera_token_expiry` (date) — when the current access token expires - `coursera_org_id` (text) — your Coursera Business organization ID **Set Privacy Rules on Config:** Data tab → Config → Privacy. Add a rule: 'This Config is visible when' → set the condition to require admin role (e.g., Current User's role is 'admin'). This restricts all Config records — including the client secret — to admin users only. Never expose Config data to regular users. **Manually create one Config record:** In Bubble's Data tab → App Data → Config → New Entry. Enter your clientId, clientSecret, and orgId values. Leave access_token and token_expiry empty — the refresh workflow will populate them.

This Backend Workflow exchanges your clientId and clientSecret for a Coursera access token using the OAuth 2.0 Client Credentials grant. First, add the token endpoint to your API Connector. Go to Plugins tab → API Connector. Add a new API Group: **Coursera OAuth**. Add a call: - Name: Get Access Token - Method: POST - URL: `https://api.coursera.org/oauth2/client_credentials/token` - Body type: application/x-www-form-urlencoded - Body parameters: - `grant_type` = `client_credentials` - Authorization method: **Basic Auth** — with username = `<client_id>` (dynamic) and password = `<client_secret>` (dynamic, mark Private) Initialize this call with real credentials to detect the response: you should see `access_token`, `token_type` (Bearer), and `expires_in` fields. Now go to Settings → API → enable 'This app exposes a Workflow API'. Open Backend Workflows. Create a new Backend Workflow: **RefreshCourseraToken** (no parameters). Workflow actions: 1. **Search for Config** → search for the one Config record (your app has only one) 2. **Call Coursera OAuth - Get Access Token** → set username to Config's coursera_client_id, set password to Config's coursera_client_secret 3. **Make changes to Config record:** - `coursera_access_token` → Result of Step 2's access_token - `coursera_token_expiry` → Current date/time + 3600 seconds (you can use a Calculate: Current date/time + 50 minutes as a safety margin) **Schedule the refresh to run every 50 minutes:** In Backend Workflows, create a **Recurring Event**: schedule RefreshCourseraToken every 50 minutes. This ensures the access token never expires during business hours. The token is valid for approximately 1 hour — the 50-minute interval provides a 10-minute buffer.

1{
2  "method": "POST",
3  "url": "https://api.coursera.org/oauth2/client_credentials/token",
4  "headers": {
5    "Authorization": "Basic <base64(clientId:clientSecret)>",
6    "Content-Type": "application/x-www-form-urlencoded"
7  },
8  "body": {
9    "grant_type": "client_credentials"
10  }
11}

Add a second API Group in the API Connector: **Coursera API**. Set the Base URL to `https://api.coursera.org`. At the API Group level, add a shared header: - **Authorization**: `Bearer <access_token>` — this will be set dynamically from the Config record in each call **Call 1 — Get Course Catalog:** Add a call: - Name: Get Courses - Method: GET - URL: `/api/businesses/v1/programUserData.v1` - Parameters: `q` = `getCourseraUserData`, `limit` = `50`, `start` = `0` (pagination offset) - Use as: Data Note: Specific Coursera API endpoint paths depend on your contract type (for Business vs. content partner access). Your Coursera account manager will provide the exact endpoint documentation for your account type. The base URL and authentication pattern remain the same. **Call 2 — Get Enrollments:** Add a call: - Name: Get Enrollments - Method: GET - URL: `/api/businesses/v1/userEnrollments.v1` - Parameters: `limit` = `50`, `start` = `<start>` (dynamic, for pagination) - Use as: Data **Call 3 — Get Completions:** Add a call: - Name: Get Completions - Method: GET - URL: `/api/businesses/v1/completions.v1` - Parameters: `limit` = `50`, `start` = `0` For all calls: set the Authorization header value dynamically by reading from the Config record at the start of each workflow chain: - Before calling any Coursera API, add a Data action: 'Search for Config' → store result in a Custom State `current_config` - Pass `current_config's coursera_access_token` as the Authorization Bearer value

1{
2  "method": "GET",
3  "url": "https://api.coursera.org/api/businesses/v1/userEnrollments.v1",
4  "headers": {
5    "Authorization": "Bearer <access_token>"
6  },
7  "params": {
8    "limit": "50",
9    "start": "<start_offset>"
10  }
11}

Create a page `coursera-dashboard` in your Bubble app. Access to this page should be restricted to admin users only (add a page-load condition that redirects non-admin users). **Token freshness check on page load:** Add a page-load workflow: 'Search for Config' (the single Config record). If Config's coursera_token_expiry is in the past → schedule RefreshCourseraToken Backend Workflow and wait before proceeding. If Config's coursera_access_token is empty → show an error message prompting admins to run the initial token refresh manually. **Enrollment list:** Add a Repeating Group. Data Source: 'Get data from external API → Coursera API - Get Enrollments'. Set the Authorization header to `Bearer [Config's coursera_access_token]` by referencing the Custom State loaded on page load. Each enrollment record from Coursera's API contains a Coursera `userId` (internal identifier) — not an employee name or email. To display employee names, you need a mapping table. **Building the userId-to-employee mapping:** Coursera's admin dashboard allows exporting a learner roster as a CSV. Request this export from your Coursera for Business admin. Create a Bubble Data Type: **CourseraUser** with fields: `coursera_user_id` (text), `full_name` (text), `email` (text), `department` (text). Import the CSV: Bubble's built-in CSV import (Data tab → App Data → CourseraUser → Upload CSV) populates this Data Type with your roster. In the enrollment Repeating Group, for each cell: 'Search for CourseraUsers where coursera_user_id = Current cell's userId' and display the matching full_name and email. For RapidDev's approach to building enterprise Coursera dashboards on Bubble — including multi-department filtering and automated roster sync patterns — see rapidevelopers.com/contact for a free scoping session.

Coursera's API uses numeric offset-based pagination: every response includes a `meta` object with `pagination` data containing the `next` offset and `total` count. **Pagination in Bubble:** Add a Custom State to your dashboard page: `pagination_start` (number, default 0). Set the Enrollments API call's `start` parameter to this Custom State value. Below the Repeating Group, add a 'Load More' button. Its workflow: 1. Check if 'pagination_start + 50 < total enrollment count' (use the `meta.pagination.total` from the last API response, stored in another Custom State `total_enrollments`) 2. If true: set `pagination_start` = `pagination_start + 50` 3. The Repeating Group re-fetches with the new start value For the total count, read `meta's total` from the enrollment API response and store it in a Custom State on the first load. **Completion rate display:** For each enrolled employee, call the Get Completions API to check their completion status for each course. This is WU-intensive — avoid calling it per-enrollment-row in a Repeating Group. Instead: 1. Build a 'Sync Completions' Backend Workflow that fetches all completions and stores them in a Bubble Data Type `CourseraCompletion` with fields: `coursera_user_id`, `course_id`, `completed_at`, `grade` 2. Run this workflow on demand (admin 'Sync Now' button) or on a daily schedule 3. Bind the Repeating Group to the locally cached CourseraCompletion data instead of live API calls This pattern — sync API data to Bubble DB, display from local cache — is essential for any Coursera dashboard with more than 50 learners. It dramatically reduces WU consumption and page load times.

If your organization does not have Coursera Partner API access (no enterprise agreement or credentials from a Coursera account manager), the CSV import path provides the same enrollment and completion data for dashboard purposes. **How to export from Coursera for Business:** 1. Log into your Coursera for Business admin dashboard at coursera.org/business 2. Go to Analytics → Learner Progress (or similar — exact navigation varies by Coursera dashboard version) 3. Export the learner progress report as CSV 4. The CSV contains: user email, full name, course name, enrollment date, completion status, completion date, grade/score **Importing into Bubble:** Create a Data Type: **CourseraEnrollment** with fields matching the CSV columns: `user_email` (text), `user_name` (text), `course_name` (text), `enrolled_at` (date), `completed` (yes/no), `completed_at` (date), `grade` (text). In Data tab → App Data → CourseraEnrollment, click 'Upload CSV'. Map the CSV columns to Bubble fields. Import. Build the same dashboard Repeating Group but bound to the local CourseraEnrollment Data Type. Add a 'Last import' timestamp field to a Config record and display it prominently — CSV data is a point-in-time snapshot, not live. Add a 'Re-import' button on the admin panel that clears all existing CourseraEnrollment records and re-imports a fresh CSV. A Bubble workflow for deletion: 'Delete a list of Things' where the list is 'Search for CourseraEnrollments' (all records). This approach gives you 90% of the dashboard value without any API credentials. Many Coursera for Business subscribers use this pattern successfully alongside their standard subscription.