How to Integrate Bolt.new with LinkedIn Learning

Before writing any code, be clear about what LinkedIn Learning's API access actually looks like. LinkedIn Learning offers two types of API access, and neither is a simple public REST API you can call with an API key. The first option is LTI (Learning Tools Interoperability), an education industry standard for connecting learning platforms to each other. LinkedIn Learning supports LTI 1.0 and 1.3. With LTI, your learning management system can launch LinkedIn Learning content, pass user identity, and receive completion events. The catch: LTI integration requires a paid LinkedIn Learning enterprise or Teams license (starting around $30/user/month), a formal request to LinkedIn's enterprise support team to enable LTI for your account, and technical implementation of the LTI protocol. This is primarily used by large companies integrating LinkedIn Learning into existing LMS platforms like Workday or Cornerstone. The second option is using LinkedIn's developer platform at developer.linkedin.com, but the content API is not there. What IS there is the LinkedIn Marketing API (for ads), Sign In with LinkedIn (OAuth), and the LinkedIn Pages API (for company pages). None of these give you access to Learning course content. For 99% of Bolt developers, the practical choice is: build a curated course recommendation system using a database you control (Supabase works great), store course links and metadata manually, and link users out to LinkedIn Learning to watch the content. This is actually what many 'learning platforms' do — they curate external content rather than host it themselves.

1// LinkedIn Learning URL patterns for deep links:
2// Course page: https://www.linkedin.com/learning/[course-slug]
3// Specific video: https://www.linkedin.com/learning/[course-slug]/[video-slug]
4// Search: https://www.linkedin.com/learning/search?keywords=[query]
5// Category: https://www.linkedin.com/learning/topics/[topic-slug]
6
7// These URLs work for any LinkedIn Learning subscriber.
8// Course slugs are visible in the LinkedIn Learning URL when browsing.

For the curated learning portal approach, Supabase is the ideal backend. Create a courses table that stores all the metadata you want to display and filter on. The key fields are: the LinkedIn Learning course URL (the link users click through to watch), title and description (copied from the LinkedIn Learning course page), duration in minutes, skill tags as an array for multi-value filtering, difficulty level, and category. You will also want a user_enrollments or user_completions table to track which users have been assigned or completed which courses. With Supabase Row Level Security (RLS), you can restrict which users can add courses (admin-only) versus who can view them (all authenticated users) and who can mark completions (only their own records). Seeding the database: this is the manual part. Browse LinkedIn Learning for courses relevant to your audience, and for each one, copy the title, URL, duration (shown on the course page), and choose skill tags. You can also use the LinkedIn Learning API in the browser's DevTools network tab — when you load a course page on LinkedIn Learning, the page makes internal API calls that return structured course data you can capture and import, though this is an unofficial workaround and may break.

1-- Supabase migration: create_learning_portal_tables
2CREATE TABLE courses (
3  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
4  title TEXT NOT NULL,
5  description TEXT,
6  url TEXT NOT NULL,
7  thumbnail_url TEXT,
8  duration_minutes INTEGER,
9  skill_tags TEXT[] DEFAULT '{}',
10  difficulty TEXT CHECK (difficulty IN ('beginner', 'intermediate', 'advanced')),
11  category TEXT,
12  is_active BOOLEAN DEFAULT true,
13  created_at TIMESTAMPTZ DEFAULT now()
14);
15
16CREATE TABLE user_enrollments (
17  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
18  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
19  course_id UUID REFERENCES courses(id) ON DELETE CASCADE,
20  status TEXT CHECK (status IN ('assigned', 'in_progress', 'completed')) DEFAULT 'assigned',
21  enrolled_at TIMESTAMPTZ DEFAULT now(),
22  completed_at TIMESTAMPTZ,
23  UNIQUE(user_id, course_id)
24);
25
26ALTER TABLE courses ENABLE ROW LEVEL SECURITY;
27ALTER TABLE user_enrollments ENABLE ROW LEVEL SECURITY;
28
29CREATE POLICY "Authenticated users can view active courses"
30  ON courses FOR SELECT TO authenticated
31  USING (is_active = true);
32
33CREATE POLICY "Users manage own enrollments"
34  ON user_enrollments FOR ALL TO authenticated
35  USING (auth.uid() = user_id);

The API routes for the learning portal need to support the filtering patterns users expect: searching by keyword, filtering by category and difficulty, filtering by skill tag, and fetching a user's enrolled courses with completion status. Supabase's JavaScript client makes query building clean with chainable filter methods. For keyword search across course titles and descriptions, use Supabase's full-text search (textsearch) or the ILIKE operator for simpler pattern matching. Full-text search gives better relevance ranking for a large catalog; ILIKE is simpler to implement and works well for catalogs under a few hundred courses. For skill tag filtering, PostgreSQL's @> (array contains) operator checks if the skill_tags array includes all of the requested tags — useful when users filter by multiple skills at once. The enrollment status endpoint is separate from the course listing — it joins courses with the current user's enrollment records to show status (not enrolled, in progress, completed) on each course card. This query can be made in a single Supabase call using a foreign table join.

1// app/api/learning/courses/route.ts
2import { createClient } from '@supabase/supabase-js';
3import { NextResponse } from 'next/server';
4
5const supabase = createClient(
6  process.env.NEXT_PUBLIC_SUPABASE_URL!,
7  process.env.SUPABASE_SERVICE_ROLE_KEY!
8);
9
10export async function GET(request: Request) {
11  const { searchParams } = new URL(request.url);
12  const search = searchParams.get('search');
13  const category = searchParams.get('category');
14  const difficulty = searchParams.get('difficulty');
15  const skill = searchParams.get('skill');
16  const page = parseInt(searchParams.get('page') || '1');
17  const limit = parseInt(searchParams.get('limit') || '20');
18
19  let query = supabase
20    .from('courses')
21    .select('*', { count: 'exact' })
22    .eq('is_active', true)
23    .range((page - 1) * limit, page * limit - 1);
24
25  if (search) query = query.ilike('title', `%${search}%`);
26  if (category) query = query.eq('category', category);
27  if (difficulty) query = query.eq('difficulty', difficulty);
28  if (skill) query = query.contains('skill_tags', [skill]);
29
30  const { data, count, error } = await query;
31  if (error) return NextResponse.json({ error: error.message }, { status: 500 });
32
33  return NextResponse.json({ courses: data, total: count, page, limit });
34}

The frontend for the LinkedIn Learning portal combines a searchable, filterable course grid with enrollment tracking. The key UX pattern is course cards that show a thumbnail (use LinkedIn Learning's default course thumbnails or a colored gradient fallback), title, duration, difficulty badge, and skill tags. An 'Enroll' button marks the user as enrolled and a 'Mark Complete' button updates the status. Since clicking a course takes users to LinkedIn Learning (a different website), open course links in a new tab. This is important because users will come back to your portal after watching — they won't navigate back from LinkedIn Learning. Track the click as an implicit 'in_progress' enrollment status update: when a user clicks through to LinkedIn Learning, automatically update their enrollment status from 'assigned' to 'in_progress' if they were enrolled. For the admin side (adding and editing courses), build a simple form that lets admins paste in a LinkedIn Learning URL and the rest of the fields. You could pre-fill some metadata by fetching the LinkedIn Learning course page and scraping the Open Graph tags (og:title, og:description, og:image) — a proxy API route can fetch the HTML and extract the og tags server-side, which is acceptable for one-time course setup and avoids CORS issues.

If your use case is actually LinkedIn advertising — managing campaigns, pulling performance metrics, or targeting LinkedIn audiences — the LinkedIn Marketing API is a separate, legitimate API that works well from Bolt.new. This is completely different from LinkedIn Learning and is the likely intent behind some 'LinkedIn Learning API' searches (the GSC query mismatch mentioned in the page brief). To use the LinkedIn Marketing API: go to developer.linkedin.com, create an application, and request access to the Marketing Developer Platform (requires approval, typically 1-3 business days for established companies). The API uses OAuth 2.0 for authentication — users authorize your app to access their LinkedIn Ads account. Once authorized, you get an access token you can use to call the Marketing API endpoints. Key endpoints include: adAccountsV2 (list ad accounts), adCampaignsV2 (create and manage campaigns), adAnalytics (performance metrics: impressions, clicks, spend, conversions), and audienceInsights (demographic data). All endpoints are HTTPS REST APIs that work from Bolt's WebContainer. Store the access token in your .env file during development; use your hosting platform's environment variables in production. Note: the LinkedIn Marketing API has strict rate limits (100 calls per day for most endpoints on the free tier) and access is restricted to approved partners.

1// app/api/linkedin/ad-performance/route.ts
2import { NextResponse } from 'next/server';
3
4export async function GET() {
5  const accessToken = process.env.LINKEDIN_ACCESS_TOKEN;
6  const accountId = process.env.LINKEDIN_AD_ACCOUNT_ID;
7
8  if (!accessToken || !accountId) {
9    return NextResponse.json(
10      { error: 'LINKEDIN_ACCESS_TOKEN and LINKEDIN_AD_ACCOUNT_ID required' },
11      { status: 400 }
12    );
13  }
14
15  const today = new Date();
16  const thirtyDaysAgo = new Date(today.getTime() - 30 * 86400000);
17
18  const params = new URLSearchParams({
19    'accounts[0]': `urn:li:sponsoredAccount:${accountId}`,
20    'dateRange.start.year': thirtyDaysAgo.getFullYear().toString(),
21    'dateRange.start.month': (thirtyDaysAgo.getMonth() + 1).toString(),
22    'dateRange.start.day': thirtyDaysAgo.getDate().toString(),
23    'dateRange.end.year': today.getFullYear().toString(),
24    'dateRange.end.month': (today.getMonth() + 1).toString(),
25    'dateRange.end.day': today.getDate().toString(),
26    timeGranularity: 'MONTHLY',
27    fields: 'dateRange,costInLocalCurrency,impressions,clicks',
28  });
29
30  const response = await fetch(
31    `https://api.linkedin.com/v2/adAnalyticsV2?${params}`,
32    { headers: { Authorization: `Bearer ${accessToken}`, 'LinkedIn-Version': '202403' } }
33  );
34
35  if (!response.ok) {
36    return NextResponse.json({ error: 'LinkedIn API error', status: response.status }, { status: 502 });
37  }
38
39  return NextResponse.json(await response.json());
40}