Lynda (LinkedIn Learning)

Before setting up any proxy or FlutterFlow configuration, confirm that two things are in place: (1) the organization has an active enterprise LinkedIn Learning license, and (2) a LinkedIn developer app with Learning API access is approved. To check the enterprise license: contact the organization's LinkedIn account manager or look in the LinkedIn Learning admin panel under Admin → Account → Subscription. If the organization is on an individual LinkedIn Premium plan rather than an enterprise Learning license, the API path is not available — LinkedIn Learning API is enterprise-only. To apply for API access: go to developer.linkedin.com and create a new LinkedIn application if you don't have one. In the application's Products section, look for the LinkedIn Learning API product and click Request Access. Fill in the use case description (a mobile corporate-learning app for internal use), the expected call volume, and the specific endpoints you need. LinkedIn reviews these requests manually. The review process typically takes several business days to a couple of weeks. Track the status in the developer portal. Do not proceed with building the proxy or FlutterFlow screens until API access is confirmed. The client credentials only work after the Learning API product is approved for the application — a valid-looking client ID and secret will still return 403 errors if the Learning API product is not approved. While waiting for approval, use this time to design your FlutterFlow screens and decide which endpoints you need (catalog, learner activity, assigned learning paths).

The proxy function serves two purposes. First, it handles the OAuth 2.0 client credentials flow — exchanging the client ID and secret for an access token and making calls to api.linkedin.com with that token. The client secret must never appear in the FlutterFlow app bundle. Second, it caches the API responses in Firestore (for Firebase) or Supabase (for Supabase Edge Functions) on an hourly schedule, so the FlutterFlow app reads from the fast local cache rather than hitting LinkedIn's high-latency reporting endpoints on every screen. For the caching strategy: deploy two functions — an HTTP function that the FlutterFlow app calls to read cached data, and a scheduled function (Firebase Cloud Scheduler or a Supabase cron job) that refreshes the cache from LinkedIn Learning every hour. The scheduled function runs independently of the app, ensuring that when any user opens the app, the data is already fresh without waiting for a LinkedIn API call. The example below shows the scheduled cache-refresh function. The HTTP function (called by FlutterFlow) simply reads from Firestore and returns the cached data. Store the LinkedIn client ID and secret in Firebase Secret Manager or as Firebase environment variables — not in the function source code.

1// Firebase Cloud Function: LinkedIn Learning cache refresh (scheduled)
2// Runs every hour. Reads from LinkedIn, writes to Firestore.
3// index.js (Node.js 18+)
4const { onSchedule } = require('firebase-functions/v2/scheduler');
5const { https } = require('firebase-functions/v2');
6const { initializeApp } = require('firebase-admin/app');
7const { getFirestore } = require('firebase-admin/firestore');
8const fetch = require('node-fetch');
9
10initializeApp();
11const db = getFirestore();
12
13const LI_CLIENT_ID = process.env.LINKEDIN_CLIENT_ID;
14const LI_CLIENT_SECRET = process.env.LINKEDIN_CLIENT_SECRET;
15const LI_API = 'https://api.linkedin.com';
16
17async function getLinkedInToken() {
18  const params = new URLSearchParams({
19    grant_type: 'client_credentials',
20    client_id: LI_CLIENT_ID,
21    client_secret: LI_CLIENT_SECRET
22  });
23  const r = await fetch(`${LI_API}/oauth/v2/accessToken`, {
24    method: 'POST',
25    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
26    body: params.toString()
27  });
28  const data = await r.json();
29  return data.access_token;
30}
31
32// Scheduled function: refresh cache hourly
33exports.refreshLearningCache = onSchedule('every 60 minutes', async () => {
34  const token = await getLinkedInToken();
35  const headers = { 'Authorization': `Bearer ${token}` };
36
37  // Fetch course catalog (check current LinkedIn Learning API endpoint paths)
38  const catalogRes = await fetch(
39    `${LI_API}/v2/learningAssets?q=criteria&assetFilteringCriteria.assetTypes[0]=COURSE`,
40    { headers }
41  );
42  const catalog = await catalogRes.json();
43
44  // Write to Firestore
45  await db.collection('linkedinLearning').doc('catalog').set({
46    courses: catalog.elements || [],
47    updatedAt: new Date().toISOString()
48  });
49
50  console.log('LinkedIn Learning cache refreshed at', new Date().toISOString());
51});
52
53// HTTP function: serve cached data to FlutterFlow
54exports.learningProxy = https.onRequest(async (req, res) => {
55  res.set('Access-Control-Allow-Origin', '*');
56  if (req.method === 'OPTIONS') {
57    res.set('Access-Control-Allow-Methods', 'GET');
58    res.set('Access-Control-Allow-Headers', 'Content-Type');
59    res.status(204).send('');
60    return;
61  }
62
63  const resource = req.query.resource || 'catalog';
64  const doc = await db.collection('linkedinLearning').doc(resource).get();
65
66  if (!doc.exists) {
67    res.status(404).json({ error: 'Cache not populated yet. Run the scheduled refresh.' });
68    return;
69  }
70
71  res.status(200).json(doc.data());
72});

With the proxy and cache in place, configure FlutterFlow to call the HTTP `learningProxy` function to read cached LinkedIn Learning data. In FlutterFlow, click API Calls in the left navigation panel. Click + Add → Create API Group. Name it `LinkedInLearning`. Set the Base URL to your deployed HTTP proxy URL — for example `https://us-central1-your-project.cloudfunctions.net/learningProxy` (Firebase) or `https://your-project.supabase.co/functions/v1/learning-proxy` (Supabase). Do not add authentication headers at the API Group level. The proxy function reads from Firestore and returns cached data without needing the FlutterFlow app to present credentials. If you want to restrict which users can call the proxy, add Firebase App Check or a shared API key header at the group level — but for an internal corporate tool, network-level restrictions (VPN, IP allowlist) may be sufficient. Inside the group, add an API Call named `GetCatalog`. Set Method to GET. In the Variables tab, add a variable named `resource` with default value `catalog`. Set the URL query parameter to `?resource={{ resource }}`. Click the Response & Test tab and run a test (ensure the scheduled function has run at least once to populate the cache). Paste the response from the proxy — which returns `{ courses: [...], updatedAt: '...' }`. Click Generate JSON Paths. FlutterFlow will generate paths for `$.courses`, `$.courses[0].title`, `$.courses[0].description`, `$.courses[0].durationInSeconds`, and other fields from the LinkedIn Learning catalog response. Name the paths clearly for binding in the next step. Add a second API Call named `GetLearnerActivity` with `resource: learnerActivity` (once you add the corresponding cache document from the learner-reporting endpoint to the scheduled function).

1// Example API Call config (reference only)
2{
3  "api_group": "LinkedInLearning",
4  "base_url": "https://us-central1-YOUR-PROJECT.cloudfunctions.net/learningProxy",
5  "calls": [
6    {
7      "name": "GetCatalog",
8      "method": "GET",
9      "url": "?resource=catalog",
10      "json_paths": {
11        "coursesList": "$.courses",
12        "firstTitle": "$.courses[0].title.value",
13        "firstDuration": "$.courses[0].durationInSeconds",
14        "updatedAt": "$.updatedAt"
15      }
16    }
17  ]
18}

Create a FlutterFlow Data Type for a LinkedIn Learning course. Go to the Data Types section in the left navigation, click + Add Data Type, and name it `LearningCourse`. Add fields: `assetUrn` (String — the course's unique LinkedIn identifier), `title` (String), `shortDescription` (String), `durationSeconds` (Integer), `primaryAuthor` (String), `level` (String — BEGINNER, INTERMEDIATE, ADVANCED), `thumbnailUrl` (String). In the `GetCatalog` API Call settings, map the JSON paths from the LinkedIn Learning catalog response to the `LearningCourse` Data Type fields. Note that LinkedIn Learning's API returns localized text inside nested objects (e.g. `title.value` for the course title, `shortDescription.value` for the description) — map these in the JSON paths or flatten them in the proxy before returning. On the catalog screen, add a ListView or GridView powered by the `GetCatalog` API Call. Inside each list item, show the course thumbnail (via a Network Image widget bound to `currentCourse.thumbnailUrl`), the `title`, the author, the duration formatted as minutes (divide `durationSeconds` by 60 using a FlutterFlow math expression), and the `level` displayed as a colored Badge widget. Add a search bar at the top of the screen using a FlutterFlow Search bar widget with a local filter on the `title` field of the loaded course list. Since the data comes from cache (not a live API), local filtering is fast and doesn't require additional API calls. Add a header row showing the `updatedAt` timestamp from the catalog response formatted as 'Catalog updated X minutes ago' to set expectations for the user that this is cached data.

The course catalog covers the browsing use-case. For the L&D management dashboard — completion rates, hours watched, learner progress — you need LinkedIn Learning's learner reporting API endpoints. These are the high-latency endpoints noted in the integration overview. Calling them on every screen open in a FlutterFlow app is not viable; the response times can reach several seconds, making the app feel broken. The solution is to extend the scheduled Firebase function to also fetch and cache learner reporting data alongside the catalog. Add a second Firestore document (e.g. `linkedinLearning/learnerActivity`) populated by the scheduled function with organization-level learning metrics. The exact LinkedIn Learning API endpoints for learner reporting depend on the access level granted to your approved developer app — check the LinkedIn Learning API documentation for your approved scope: common endpoints include `/v2/learningClassifications` and `/v2/organizationalEntityReportingActivities`. In FlutterFlow, add a second API Call to the `LinkedInLearning` API Group named `GetLearnerActivity` (GET, `?resource=learnerActivity`). Create a Data Type `LearnerActivity` with fields for employee name, courses completed, hours watched, and completion dates. Build the dashboard screen reading from this call with summary metrics at the top (total completions, total hours) and a ranked list of top courses below. For the scheduling: the Firebase Cloud Scheduler trigger `every 60 minutes` in the code example runs automatically after deployment. If you want to give the L&D manager a manual refresh option in the app, add a Refresh button that triggers an API Call to a separate Cloud Function that immediately runs the cache refresh (rather than waiting for the hourly schedule). This optional HTTP-triggered refresh function calls the same LinkedIn Learning endpoints and updates Firestore, then the app re-fetches from the `GetLearnerActivity` API Call.

1// Add to refreshLearningCache function: learner activity caching
2// (inside the scheduled function, after the catalog fetch)
3
4async function cachelearnerActivity(token) {
5  const headers = {
6    'Authorization': `Bearer ${token}`,
7    'X-RestLi-Protocol-Version': '2.0.0'
8  };
9
10  // Replace with your approved LinkedIn Learning reporting endpoint
11  // Endpoint paths vary by approval scope — check LinkedIn Learning API docs
12  const activityRes = await fetch(
13    `${LI_API}/v2/organizationalEntityReportingActivities` +
14    `?q=criteria&organizationalEntityReportingCriteria.organizationalEntityType=ACCOUNT`,
15    { headers }
16  );
17  const activity = await activityRes.json();
18
19  await db.collection('linkedinLearning').doc('learnerActivity').set({
20    activities: activity.elements || [],
21    updatedAt: new Date().toISOString()
22  });
23}
24
25// Call this from the scheduled function:
26// await cacheLearnerActivity(token);