How to Integrate LinkedIn Ads with V0

LinkedIn's Marketing API requires creating a developer app and applying for access to the Advertising API product. This is a two-step process that takes longer than most API integrations because of LinkedIn's approval workflow. Go to developer.linkedin.com and sign in with your LinkedIn account. Click Create App. Fill in the app name, associate it with a LinkedIn Company Page (required), upload an app logo, and accept the legal agreement. After creation, you land on the app dashboard. In the app dashboard, go to the Products tab. Find Advertising API in the list of products and click Request Access. Fill out the access request form explaining your use case — be specific about which data you need and why. LinkedIn reviews applications manually. Standard developer access only gives you access to your own profile data; the Advertising API product unlocks access to Campaign Manager accounts the user authorizes. While waiting for approval, go to the Auth tab to copy your Client ID and Client Secret. Also add your redirect URI here — set it to http://localhost:3000/api/linkedin/callback for local development and add your production Vercel URL when ready (e.g., https://your-app.vercel.app/api/linkedin/callback). The redirect URI must exactly match what you use in the OAuth flow. LinkedIn's OAuth2 uses the standard Authorization Code flow. Required scopes for advertising analytics are r_ads and r_ads_reporting. You can also add rw_ads if you need to modify campaigns.

Use V0 to generate the front-end components for your LinkedIn Ads analytics dashboard. LinkedIn Ads analytics typically involve tables of campaign data, metric cards, date range selectors, and trend charts. When prompting V0, describe the data structure your API routes will return. Tell V0 that the campaigns endpoint returns an array of objects with campaignId, campaignName, status, impressions, clicks, conversions, and totalSpend. This allows V0 to generate correctly typed TypeScript interfaces and accurate data binding. For date range filtering — a common need in analytics dashboards — ask V0 to generate a date range picker using shadcn/ui's calendar component or a simple preset selector (Last 7 days, Last 30 days, Last 90 days, Custom range). The selected date range should be passed as query parameters to your API routes. LinkedIn campaign statuses have specific values: ACTIVE, PAUSED, ARCHIVED, DRAFT, CANCELED. Ask V0 to generate color-coded status badges: green for ACTIVE, yellow for PAUSED, gray for others. This visual clarity is important in a campaign dashboard where the user scans many campaigns at once.

LinkedIn's OAuth2 follows the standard Authorization Code flow. You need two API routes: one to redirect the user to LinkedIn's authorization page, and one to handle the callback and exchange the code for an access token. The login route (app/api/linkedin/login/route.ts) builds the LinkedIn authorization URL with your Client ID, the required scopes, and your redirect URI. LinkedIn's authorization endpoint is https://www.linkedin.com/oauth/v2/authorization. Include a state parameter (a random string) to prevent CSRF attacks — store it in a cookie and verify it matches in the callback. The callback route (app/api/linkedin/callback/route.ts) receives the code and state parameters from LinkedIn. Verify the state matches what you stored, then exchange the code for an access token by POSTing to https://www.linkedin.com/oauth/v2/accessToken with your Client ID, Client Secret, code, and redirect URI. LinkedIn returns an access_token and expires_in value. Store the access token in an HTTP-only cookie. LinkedIn tokens can last up to 60 days. Unlike Spotify's short-lived tokens, LinkedIn tokens are longer-lived, so a simple expiration check is often sufficient without implementing a full refresh flow. After storing the token, redirect the user back to your dashboard page. Your data-fetching API routes will read the token from the cookie for subsequent API calls.

1// app/api/linkedin/login/route.ts
2import { NextResponse } from 'next/server';
3
4export async function GET() {
5  const state = Math.random().toString(36).slice(2);
6
7  const params = new URLSearchParams({
8    response_type: 'code',
9    client_id: process.env.LINKEDIN_CLIENT_ID!,
10    redirect_uri: process.env.LINKEDIN_REDIRECT_URI!,
11    state,
12    scope: 'r_ads r_ads_reporting',
13  });
14
15  const response = NextResponse.redirect(
16    `https://www.linkedin.com/oauth/v2/authorization?${params.toString()}`
17  );
18
19  response.cookies.set('linkedin_oauth_state', state, {
20    httpOnly: true,
21    secure: process.env.NODE_ENV === 'production',
22    maxAge: 600,
23    sameSite: 'lax',
24  });
25
26  return response;
27}

With authentication working, create the API route that fetches campaign analytics from LinkedIn's API. LinkedIn's Analytics Finder API endpoint is at https://api.linkedin.com/v2/adAnalytics — it uses a complex query parameter syntax based on LinkedIn's Rest.li framework. The LinkedIn API uses a pivot + time range + date range query structure. To get campaign-level analytics, you set pivot=CAMPAIGN, specify a dateRange.start and dateRange.end, and pass the account ID (adAccountId). The account ID is the Campaign Manager account number, typically in the format urn:li:sponsoredAccount:XXXXXXXXXX. First, you need the user's ad account ID. Call https://api.linkedin.com/v2/adAccountsV2?q=search to list the accounts the authenticated user has access to. Extract the account ID from the response and use it in subsequent analytics calls. LinkedIn's Analytics API returns metrics like impressionCount, clickCount, conversionValueInLocalCurrency, costInLocalCurrency, and externalWebsiteConversions. Map these to the field names your V0 components expect. The LinkedIn API uses URN (Uniform Resource Name) format for IDs throughout — campaigns are identified as urn:li:sponsoredCampaign:12345 rather than just 12345. Your API route must handle these URN formats when filtering analytics by campaign.

1// app/api/linkedin/ads/campaigns/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { cookies } from 'next/headers';
4
5export async function GET(request: NextRequest) {
6  const cookieStore = await cookies();
7  const accessToken = cookieStore.get('linkedin_access_token')?.value;
8
9  if (!accessToken) {
10    return NextResponse.json({ error: 'Not authenticated' }, { status: 401 });
11  }
12
13  const headers = {
14    Authorization: `Bearer ${accessToken}`,
15    'LinkedIn-Version': '202401',
16  };
17
18  // Get ad accounts
19  const accountsRes = await fetch(
20    'https://api.linkedin.com/v2/adAccountsV2?q=search&search.status.values[0]=ACTIVE',
21    { headers }
22  );
23
24  if (!accountsRes.ok) {
25    return NextResponse.json(
26      { error: 'Failed to fetch ad accounts' },
27      { status: accountsRes.status }
28    );
29  }
30
31  const accountsData = await accountsRes.json();
32  const accountId = accountsData.elements?.[0]?.id;
33
34  if (!accountId) {
35    return NextResponse.json({ error: 'No ad accounts found' }, { status: 404 });
36  }
37
38  // Get analytics
39  const today = new Date();
40  const thirtyDaysAgo = new Date(today.getTime() - 30 * 24 * 60 * 60 * 1000);
41
42  const analyticsParams = new URLSearchParams({
43    q: 'analytics',
44    pivot: 'CAMPAIGN',
45    'dateRange.start.day': thirtyDaysAgo.getDate().toString(),
46    'dateRange.start.month': (thirtyDaysAgo.getMonth() + 1).toString(),
47    'dateRange.start.year': thirtyDaysAgo.getFullYear().toString(),
48    'dateRange.end.day': today.getDate().toString(),
49    'dateRange.end.month': (today.getMonth() + 1).toString(),
50    'dateRange.end.year': today.getFullYear().toString(),
51    'accounts[0]': `urn:li:sponsoredAccount:${accountId}`,
52    timeGranularity: 'ALL',
53  });
54
55  const analyticsRes = await fetch(
56    `https://api.linkedin.com/v2/adAnalytics?${analyticsParams}`,
57    { headers }
58  );
59
60  if (!analyticsRes.ok) {
61    return NextResponse.json(
62      { error: 'Failed to fetch analytics' },
63      { status: analyticsRes.status }
64    );
65  }
66
67  const analyticsData = await analyticsRes.json();
68  return NextResponse.json(analyticsData);
69}

Your LinkedIn API routes need three environment variables. Add them in Vercel Dashboard → Settings → Environment Variables with scope set to Production, Preview, and Development. LINKEDIN_CLIENT_ID: your LinkedIn app's Client ID from developer.linkedin.com. This appears in OAuth authorization URLs and is not a strict secret, but storing it as an env var keeps your code portable. LINKEDIN_CLIENT_SECRET: your LinkedIn app's Client Secret. This authorizes the token exchange step. Never add NEXT_PUBLIC_ prefix and never commit to Git. LINKEDIN_REDIRECT_URI: for production, set to https://your-app.vercel.app/api/linkedin/callback. This must exactly match one of the redirect URIs registered in your LinkedIn app's Auth settings. The mismatch between registered URI and actual redirect URI is the most common LinkedIn OAuth error. For local development, use http://localhost:3000/api/linkedin/callback and add the same value to your .env.local file. Add both URLs to your LinkedIn app's Authorized Redirect URLs list on the Auth tab — LinkedIn allows multiple redirect URIs per app. After saving variables and redeploying, test the full OAuth flow by clicking your dashboard's Connect LinkedIn button, authorizing the app, and verifying the dashboard loads campaign data.