How to Integrate Lovable with LinkedIn Learning

LinkedIn Learning API access requires two things: an active organizational LinkedIn Learning license and a LinkedIn developer application with the Learning API product enabled. Start by going to developer.linkedin.com and signing in with your LinkedIn account. Click 'Create app' and fill in the app name, your company's LinkedIn page (required), and app logo. Under 'Products', look for 'Learning and Development API' — request access to this product. LinkedIn reviews these requests and may contact you to verify your organizational license. Once your app is approved, go to the app's 'Auth' tab in the developer portal. Note the Client ID and Client Secret. For the OAuth2 scopes needed, request: r_learning_partner_catalog (course catalog read), r_learning_partner_reporting (learner activity data), and rw_learning_partner_admin if you need to assign courses programmatically. To generate an access token for your organization's learning data, use the OAuth2 client credentials flow (also called two-legged OAuth or application-only auth). Make a POST request to https://www.linkedin.com/oauth/v2/accessToken with grant_type=client_credentials, your client_id, and client_secret. This returns an access token valid for 30 minutes. For production use, your Edge Function must refresh this token before it expires — the short expiry is a LinkedIn API constraint you cannot configure around. Note: the LinkedIn Learning API is not publicly available. If you do not have an organizational LinkedIn Learning license, you will receive authorization errors when attempting to access learner data endpoints. The catalog endpoints may be accessible with lower-tier access, but learner reporting requires the full organizational license.

Open your Lovable project and click the '+' icon next to the Preview label to open the Cloud panel. Navigate to the Secrets tab and add the following secrets: - Name: LINKEDIN_CLIENT_ID — Value: your LinkedIn application Client ID - Name: LINKEDIN_CLIENT_SECRET — Value: your LinkedIn application Client Secret - Name: LINKEDIN_ORG_ID — Value: your LinkedIn organization ID (visible in your LinkedIn company page URL) Because LinkedIn Learning API tokens expire in 30 minutes and cannot be stored long-term, the Edge Function will request a fresh token on each invocation using the client credentials flow. This means you do not need to store an access token as a secret — the client ID and secret are sufficient for the Edge Function to authenticate itself. The organization ID is needed for endpoints that scope data to your specific LinkedIn Learning contract, such as learner reporting and course assignment. You can find it by navigating to your company's LinkedIn page and extracting the numeric ID from the URL. Keep these credentials strictly in Cloud → Secrets. LinkedIn's API uses client credentials that, if exposed, could be used to access your organization's employee learning records — a significant privacy concern. Never paste them into Lovable's chat or into source code.

Create a Supabase Edge Function that handles token generation and API proxying for LinkedIn Learning. Because tokens expire in 30 minutes, the function performs a fresh token request on each invocation using the client credentials flow, then uses the resulting token to call the LinkedIn Learning API endpoint. The function handles three types of requests: course catalog search (GET /v2/learningAssets), learner activity reporting (GET /v2/learningAssetsAvailableToOrganizationUser), and organization learning summary (GET /v2/learnerActivitySummaryReports). Each maps to a different LinkedIn Learning API endpoint with different required parameters. Paste the prompt below into Lovable's chat to create the function. Verify it deploys successfully by checking Cloud → Edge Functions.

1// supabase/functions/linkedin-learning/index.ts
2const LINKEDIN_TOKEN_URL = 'https://www.linkedin.com/oauth/v2/accessToken';
3const LINKEDIN_API_BASE = 'https://api.linkedin.com';
4
5async function getAccessToken(): Promise<string> {
6  const clientId = Deno.env.get('LINKEDIN_CLIENT_ID');
7  const clientSecret = Deno.env.get('LINKEDIN_CLIENT_SECRET');
8  if (!clientId || !clientSecret) throw new Error('LinkedIn credentials not configured');
9
10  const tokenBody = new URLSearchParams({
11    grant_type: 'client_credentials',
12    client_id: clientId,
13    client_secret: clientSecret,
14  });
15
16  const response = await fetch(LINKEDIN_TOKEN_URL, {
17    method: 'POST',
18    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
19    body: tokenBody,
20  });
21
22  const data = await response.json();
23  if (!data.access_token) throw new Error(`Token fetch failed: ${JSON.stringify(data)}`);
24  return data.access_token;
25}
26
27Deno.serve(async (req) => {
28  if (req.method === 'OPTIONS') {
29    return new Response(null, {
30      headers: {
31        'Access-Control-Allow-Origin': '*',
32        'Access-Control-Allow-Methods': 'POST, OPTIONS',
33        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
34      },
35    });
36  }
37
38  try {
39    const accessToken = await getAccessToken();
40    const { endpoint, params } = await req.json();
41    const orgId = Deno.env.get('LINKEDIN_ORG_ID');
42
43    let apiUrl: string;
44    if (endpoint === 'catalog') {
45      const q = new URLSearchParams({ q: 'criteria', ...(params || {}) });
46      apiUrl = `${LINKEDIN_API_BASE}/v2/learningAssets?${q}`;
47    } else if (endpoint === 'learner_activity') {
48      const q = new URLSearchParams({ organizationId: orgId!, ...(params || {}) });
49      apiUrl = `${LINKEDIN_API_BASE}/v2/learnerActivityReports?${q}`;
50    } else if (endpoint === 'org_summary') {
51      apiUrl = `${LINKEDIN_API_BASE}/v2/learnerActivitySummaryReports?organizationId=${orgId}`;
52    } else {
53      return new Response(JSON.stringify({ error: 'Invalid endpoint' }), {
54        status: 400,
55        headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' },
56      });
57    }
58
59    const apiResponse = await fetch(apiUrl, {
60      headers: {
61        'Authorization': `Bearer ${accessToken}`,
62        'X-Restli-Protocol-Version': '2.0.0',
63      },
64    });
65
66    const data = await apiResponse.json();
67    return new Response(JSON.stringify(data), {
68      status: apiResponse.status,
69      headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' },
70    });
71  } catch (err) {
72    return new Response(JSON.stringify({ error: err.message }), {
73      status: 500,
74      headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' },
75    });
76  }
77});

With the Edge Function deployed, use Lovable's chat to generate the learning dashboard components. For an L&D dashboard, the most valuable views are: an overview of organizational learning activity (total completions, hours logged, active learners), a per-employee progress table with filtering by department or manager, and a course catalog browser for discovering and assigning new content. The LinkedIn Learning API returns learning asset URNs as identifiers rather than simple IDs. When displaying courses, use the content title and a constructed URL in the format https://www.linkedin.com/learning/{course-slug} to link users directly to the course on LinkedIn Learning. For progress visualization, store API responses in Supabase rather than fetching live for every dashboard load. LinkedIn's learner reporting API has rate limits and higher latency than typical REST APIs — caching results hourly in a Supabase table significantly improves dashboard performance. Store the raw API response alongside a fetched_at timestamp and return cached data if it is less than one hour old. For complex enterprise deployments with thousands of employees, department hierarchies, and custom learning path tracking, RapidDev's team can help architect the data pipeline from LinkedIn Learning API through Supabase to your dashboard.