Teachable

Log in to your Teachable school as the school owner. In the left sidebar, click 'Settings' → in the Settings navigation, look for 'API.' If the API section does not appear, your Teachable school is on the Free or Basic plan — API access is restricted to Pro plan and above. On the API settings page, you will see an option to generate or view your API key. Click 'Generate API key' (or reveal the existing key if one was previously created). Copy the key immediately and save it in a password manager. Teachable generates one API key per school. This single key is used for all API integrations — there are no scoped keys and no way to create separate keys for different integrations. Before rotating or regenerating the key, check whether any other systems (zapier automations, other Bubble apps, custom code) use the same key, as regenerating invalidates the old key for all of them simultaneously. The Teachable API key is a static credential — it does not expire unless manually regenerated. Treat it with the same care as a password. Also note the base URL for all Teachable API calls: `https://developers.teachable.com/v1`.

1// Teachable API reference
2// Base URL: https://developers.teachable.com/v1
3//
4// Authentication: custom header (NOT Bearer token)
5// Header Key:   apiKey       ← camelCase, exactly this spelling
6// Header Value: your_teachable_api_key
7//
8// Common mistake:
9// Key:   Authorization        ← WRONG — causes 401 errors
10// Value: Bearer your_key      ← WRONG — wrong format for Teachable
11//
12// Key endpoints:
13// GET /courses                     — list all courses
14// GET /courses/{id}/enrollments    — enrollments per course
15// GET /courses/{id}/transactions   — transactions per course
16// GET /users                       — student list
17//
18// Plan requirement: Pro plan or above for API access
19// One key per school — no scoped keys

Open your Bubble app editor and click 'Plugins' in the left sidebar. If the API Connector by Bubble is not already installed, click 'Add plugins,' search for 'API Connector,' and install it — it is free. Return to the Plugins tab, click 'API Connector,' and click 'Add another API.' Name this API group 'Teachable.' In the 'Root URL' field, enter `https://developers.teachable.com/v1`. Under 'Shared headers across all calls,' click 'Add a shared header.' In the key field, type exactly: `apiKey` — this is case-sensitive. In the value field, paste your Teachable API key. Check the 'Private' checkbox. This marks the `apiKey` header as server-side only — Bubble will use it when making API calls from its servers, and the key value will never appear in a browser's DevTools Network tab for any visitor to your app. Do NOT add an `Authorization` header or use `Bearer` format — Teachable's API does not use the Authorization header name for authentication. If you add `Authorization: Bearer {key}`, every call returns 401 even with a valid key. Add a second shared header: key `Accept`, value `application/json` — no Private checkbox needed. This completes the API group setup.

1// Bubble API Connector — Teachable group configuration
2{
3  "api_group_name": "Teachable",
4  "root_url": "https://developers.teachable.com/v1",
5  "shared_headers": [
6    {
7      "key": "apiKey",
8      "value": "your_teachable_api_key_here",
9      "private": true,
10      "note": "camelCase 'apiKey' — NOT 'Authorization'"
11    },
12    {
13      "key": "Accept",
14      "value": "application/json"
15    }
16  ]
17}
18
19// MOST COMMON ERROR — wrong header setup:
20// key: 'Authorization'
21// value: 'Bearer your_key'
22// Result: 401 Unauthorized on every call
23//
24// Teachable API does NOT use Authorization: Bearer format
25// The correct header key is ONLY: apiKey

Inside the Teachable API group, click 'Add call.' Name it 'Get Courses.' Set the method to GET. Endpoint: `/courses`. Set 'Use as' to 'Data' — this tells Bubble the response should be mappable to a list data type for binding to Repeating Groups. Add URL parameters: click 'Add parameter.' Add `is_published` with value `true` — this filters out draft courses so only published courses appear in your storefront. Add `page` with value `1` and `per` with value `50` (50 is Teachable's maximum per page). The `per` parameter controls how many courses Teachable returns; omitting it uses Teachable's default, which may return fewer courses than your school has. Now click 'Initialize call.' Bubble fires a real GET request to Teachable using your Private `apiKey` header. If your key is valid and your school has at least one published course, Teachable returns a JSON response with a `courses` array and a `meta` object. Bubble detects the response fields: `id`, `name`, `heading`, `image_url`, `is_published`, and the `meta` object containing `total_count`, `page`, and `per`. Click 'Save.' The `meta.total_count` field tells you the total number of courses matching the filter — if it is greater than 50, you will need pagination to fetch additional pages. The total count divided by 50 (rounded up) tells you how many pages exist.

1// GET /courses — Teachable API response structure
2{
3  "courses": [
4    {
5      "id": 12345,
6      "name": "Advanced Photography",
7      "heading": "Master light, composition, and editing",
8      "image_url": "https://cdn.teachable.com/images/...",
9      "is_published": true,
10      "price": 4900,
11      "sale_price": null
12    },
13    {
14      "id": 12346,
15      "name": "Brand Photography Masterclass",
16      "heading": "Build your photography business",
17      "image_url": "https://cdn.teachable.com/images/...",
18      "is_published": true,
19      "price": 9700,
20      "sale_price": 7500
21    }
22  ],
23  "meta": {
24    "total_count": 12,
25    "page": 1,
26    "per": 50
27  }
28}
29
30// IMPORTANT: price is in CENTS
31// $49.00 course → price = 4900
32// Display: Current cell's course's price / 100 :formatted as $#,##0.00
33//
34// Pagination: if meta.total_count > 50, request page 2 with page=2

With the Get Courses call initialized, build the public-facing course catalog page. In your Bubble page editor, add a Repeating Group element. Set 'Type of content' to 'Teachable - Get Courses - course' (the name Bubble generates from your call name). Set 'Data source' to 'Get data from an external API → Teachable → Get Courses.' In the parameters, set `is_published = true`, `per = 50`, `page = 1`. Inside the Repeating Group's first cell, add the course card components: an Image element bound to `Current cell's course's image_url`; a Text element for `Current cell's course's name` (styled as a heading); a Text element for `Current cell's course's heading` (subtitle description); a Text element for price using the expression `Current cell's course's price / 100 :formatted as $#,##0.00` — this converts the cents integer to a dollar display. If Teachable provides a `sale_price` field, add a conditional: when `Current cell's course's sale_price is not empty`, show the sale price in a highlighted color and the original price with strikethrough styling. Add a Button labeled 'Enroll Now.' This button should NOT submit any form or call any Bubble workflow related to payments. Its action should be: 'Open an external website' → link to Teachable's school URL for that specific course (the URL is typically `https://yourschool.teachable.com/p/course-slug` — note that the API response `id` is a numeric ID, not the slug, so you may need to construct the URL or include the `url` field in the API response if Teachable returns it). Important: Bubble must never handle Teachable payment processing. The 'Enroll Now' button opens Teachable's native checkout — that is where payment, confirmation, and course access all happen.

1// Bubble Repeating Group — Teachable course catalog
2// Type of content: Teachable - Get Courses - course
3// Data source: Get data from external API → Teachable → Get Courses
4//   Parameters: is_published=true, per=50, page=1
5
6// Inside RG first cell:
7// Image element:
8//   Source = Current cell's course's image_url
9//
10// Text (course name):
11//   Current cell's course's name
12//
13// Text (heading/subtitle):
14//   Current cell's course's heading
15//
16// Text (price):
17//   Current cell's course's price / 100 :formatted as $#,##0.00
18//
19// Sale price (conditional — show when sale_price is not empty):
20//   Current cell's course's sale_price / 100 :formatted as $#,##0.00
21//   Style: highlighted, original price with strikethrough
22//
23// 'Enroll Now' button:
24//   Action: Open an external website
25//   URL: Teachable checkout URL for this course
26//   (Never handle payment in Bubble — always redirect to Teachable)
27//
28// Pagination — if more than 50 courses:
29//   Add 'Load More' button that increments page parameter
30//   Check meta.total_count > 50 to determine if button should show

To build an ops dashboard showing enrollment counts and completion rates per course, add a second API call in the Teachable group. Click 'Add call' → name it 'Get Course Enrollments.' Method: GET. Endpoint: `/courses/<id>/enrollments` — add a URL parameter named `id` (type: dynamic). Add query parameters: `perPage` with value `100` (Teachable's pagination for enrollments), `page` with value `1`. Set 'Use as' to 'Data.' Click 'Initialize call' — you will need to provide a real course `id` value during initialization (use a numeric ID from one of your courses, visible in your Teachable dashboard URL or from a Get Courses call result). The response returns an array of enrollment objects with fields including `percentage_completed` (a decimal number from 0 to 100, e.g., `67.5` means 67.5% complete), `lectureable_completions_count`, and student information. Store this in a Bubble Data Type: create a type named `TeachableEnrollment` with fields `course_id` (number), `course_name` (text), `student_email` (text), `percentage_completed` (number), `enrolled_at` (date). Build a Backend Workflow named 'Sync Teachable Enrollments' (requires paid Bubble plan for Backend Workflows). Inside, for each course fetched by Get Courses, call Get Course Enrollments with the course's `id` as the parameter, then create TeachableEnrollment records for each returned enrollment. Schedule this to run nightly. Your ops dashboard queries from Bubble's database for fast performance.

1// GET /courses/{id}/enrollments — response structure
2{
3  "enrollments": [
4    {
5      "id": 98765,
6      "enrolled_at": "2026-05-15T09:22:00Z",
7      "percentage_completed": 67.5,
8      "lectureable_completions_count": 12,
9      "user": {
10        "id": 55555,
11        "email": "student@example.com",
12        "name": "Jane Smith"
13      }
14    }
15  ],
16  "meta": {
17    "total_count": 145,
18    "page": 1,
19    "per": 100
20  }
21}
22
23// Bubble Data Type: TeachableEnrollment
24//   course_id              (number) — Teachable course numeric ID
25//   course_name            (text)
26//   student_email          (text)
27//   percentage_completed   (number) — 0 to 100, e.g., 67.5
28//   enrolled_at            (date)
29//
30// Ops dashboard expressions:
31// Total enrollments: Search for TeachableEnrollments:count
32// Average completion: Search for TeachableEnrollments where course_id = X
33//                     :sum of percentage_completed / :count
34// Completed students: Search for TeachableEnrollments
35//                     :filtered where percentage_completed = 100
36//                     :count

Student enrollment records, email addresses, completion rates, and transaction amounts are sensitive personal and financial data. Storing any of this in Bubble's database without privacy rules creates a security risk: Bubble's default behavior allows any logged-in user of your app to query data types via Bubble's native API. If your Bubble app has any public-facing signup, this could expose student data to non-admin users. Go to Bubble's Data tab → Privacy. For the 'TeachableEnrollment' Data Type (and any other type storing student or transaction data): click 'Define rules' → 'Add a rule.' Set the condition: 'Current User's is_admin = yes' (add an `is_admin` yes/no field to your Bubble User data type if it does not exist, with a default of `no`). Under 'When this rule applies,' check both 'Find this in searches' and 'See these fields → All fields.' Under 'When this rule does NOT apply,' ensure both are unchecked — this blocks all access for non-admin users. Set `is_admin = yes` only for your own account by going to Data tab → App data → User records → find your user → edit → set `is_admin = yes`. Apply the same privacy rule to any transaction data types. For compliance note: if your school has students from the EU, GDPR obligations apply to storing student email addresses in Bubble. Consider storing only aggregated metrics (completion rate, enrollment count) rather than individual student PII if full GDPR compliance is a concern. If RapidDev can help you design the appropriate data minimization approach for your compliance requirements, reach out for a free scoping call at rapidevelopers.com/contact.

1// Bubble Privacy Rules — TeachableEnrollment Data Type
2// Data tab → Privacy → TeachableEnrollment
3//
4// Rule: 'Admin Only'
5// Condition: Current User's is_admin = yes
6//
7// When rule applies:
8//   [x] Find this in searches
9//   [x] See these fields → All Fields
10//
11// When rule does NOT apply:
12//   [ ] Find this in searches    (blocked)
13//   [ ] See any fields           (blocked)
14//
15// Bubble User type — add field:
16//   is_admin (yes/no, default: no)
17//
18// Set is_admin = yes for your account:
19// Data tab → App data → User records → find your email → edit → is_admin = yes
20//
21// Also apply to:
22//   TeachableTransaction (if you create this type for revenue data)
23//   Any type storing student email addresses
24//
25// Note: transaction amounts in Teachable API are in cents
26// GET /courses/{id}/transactions → amount field in cents → divide by 100