How to Integrate Bolt.new with Pinterest Ads

1// lib/pinterest.ts
2const PINTEREST_API_BASE = 'https://api.pinterest.com/v5';
3const TOKEN_ENDPOINT = 'https://api.pinterest.com/v5/oauth/token';
4
5let cachedToken: { token: string; expiresAt: number } | null = null;
6
7export async function getPinterestToken(): Promise<string> {
8  // Cache token for 25 days (expires at 30 days, refresh early)
9  if (cachedToken && Date.now() < cachedToken.expiresAt) {
10    return cachedToken.token;
11  }
12
13  const appId = process.env.PINTEREST_APP_ID;
14  const appSecret = process.env.PINTEREST_APP_SECRET;
15  const refreshToken = process.env.PINTEREST_REFRESH_TOKEN;
16
17  if (!appId || !appSecret || !refreshToken) {
18    throw new Error(
19      'Missing Pinterest credentials. Set PINTEREST_APP_ID, PINTEREST_APP_SECRET, ' +
20      'and PINTEREST_REFRESH_TOKEN in .env'
21    );
22  }
23
24  const credentials = Buffer.from(`${appId}:${appSecret}`).toString('base64');
25
26  const response = await fetch(TOKEN_ENDPOINT, {
27    method: 'POST',
28    headers: {
29      Authorization: `Basic ${credentials}`,
30      'Content-Type': 'application/x-www-form-urlencoded',
31    },
32    body: new URLSearchParams({
33      grant_type: 'refresh_token',
34      refresh_token: refreshToken,
35      scope: 'ads:read user_accounts:read',
36    }),
37  });
38
39  const data = await response.json() as {
40    access_token?: string;
41    expires_in?: number;
42    refresh_token?: string;
43    error?: string;
44    error_description?: string;
45  };
46
47  if (!response.ok || !data.access_token) {
48    throw new Error(
49      `Pinterest token refresh failed: ${data.error_description || data.error || response.status}`
50    );
51  }
52
53  cachedToken = {
54    token: data.access_token,
55    // Cache for 25 days (token valid 30 days, refresh 5 days early)
56    expiresAt: Date.now() + 25 * 24 * 60 * 60 * 1000,
57  };
58
59  return cachedToken.token;
60}
61
62export async function pinterestFetch<T = unknown>(
63  endpoint: string,
64  options: {
65    params?: Record<string, string>;
66    method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
67    body?: Record<string, unknown>;
68  } = {}
69): Promise<T> {
70  const token = await getPinterestToken();
71
72  const url = new URL(`${PINTEREST_API_BASE}/${endpoint}`);
73  if (options.params) {
74    Object.entries(options.params).forEach(([k, v]) => url.searchParams.set(k, v));
75  }
76
77  const response = await fetch(url.toString(), {
78    method: options.method || 'GET',
79    headers: {
80      Authorization: `Bearer ${token}`,
81      'Content-Type': 'application/json',
82    },
83    body: options.body ? JSON.stringify(options.body) : undefined,
84  });
85
86  if (!response.ok) {
87    const err = await response.json().catch(() => ({})) as { message?: string };
88    throw new Error(`Pinterest API ${response.status}: ${err.message || response.statusText}`);
89  }
90
91  return response.json() as Promise<T>;
92}

1// app/api/pinterest/auth/callback/route.ts
2import { NextResponse } from 'next/server';
3
4export async function GET(request: Request) {
5  const { searchParams } = new URL(request.url);
6  const code = searchParams.get('code');
7  const error = searchParams.get('error');
8
9  if (error) {
10    return NextResponse.json({ error, description: searchParams.get('error_description') }, { status: 400 });
11  }
12
13  if (!code) {
14    return NextResponse.json({ error: 'No authorization code received from Pinterest' }, { status: 400 });
15  }
16
17  const appId = process.env.PINTEREST_APP_ID;
18  const appSecret = process.env.PINTEREST_APP_SECRET;
19  const redirectUri = `${process.env.NEXT_PUBLIC_APP_URL}/api/pinterest/auth/callback`;
20
21  if (!appId || !appSecret) {
22    return NextResponse.json({ error: 'Pinterest app credentials not configured' }, { status: 500 });
23  }
24
25  const credentials = Buffer.from(`${appId}:${appSecret}`).toString('base64');
26
27  const response = await fetch('https://api.pinterest.com/v5/oauth/token', {
28    method: 'POST',
29    headers: {
30      Authorization: `Basic ${credentials}`,
31      'Content-Type': 'application/x-www-form-urlencoded',
32    },
33    body: new URLSearchParams({
34      grant_type: 'authorization_code',
35      code,
36      redirect_uri: redirectUri,
37    }),
38  });
39
40  const data = await response.json() as {
41    access_token?: string;
42    refresh_token?: string;
43    expires_in?: number;
44    error?: string;
45  };
46
47  if (!response.ok || !data.access_token) {
48    return NextResponse.json({ error: data.error || 'Token exchange failed' }, { status: 500 });
49  }
50
51  return NextResponse.json({
52    accessToken: data.access_token,
53    refreshToken: data.refresh_token,
54    expiresIn: data.expires_in,
55    message: 'Copy PINTEREST_ACCESS_TOKEN and PINTEREST_REFRESH_TOKEN to your .env file',
56    envLines: [
57      `PINTEREST_ACCESS_TOKEN=${data.access_token}`,
58      `PINTEREST_REFRESH_TOKEN=${data.refresh_token}`,
59    ],
60  });
61}

1// app/api/pinterest/campaigns/route.ts
2import { NextResponse } from 'next/server';
3import { pinterestFetch } from '@/lib/pinterest';
4
5interface PinterestCampaign {
6  id: string;
7  name: string;
8  status: string;
9  objective_type: string;
10  daily_spend_cap?: number;
11  lifetime_spend_cap?: number;
12  created_time: number;
13}
14
15interface PinterestCampaignAnalytic {
16  campaign_id: string;
17  date_range: { start_date: string; end_date: string };
18  SPEND_IN_DOLLAR?: number;
19  IMPRESSION_1?: number;
20  CLICK_2?: number;
21  SAVE?: number;
22  SAVE_RATE?: number;
23  OUTBOUND_CLICK?: number;
24  CHECKOUT_ROAS?: number;
25}
26
27export async function GET(request: Request) {
28  const { searchParams } = new URL(request.url);
29  const adAccountId = process.env.PINTEREST_AD_ACCOUNT_ID;
30  if (!adAccountId) {
31    return NextResponse.json({ error: 'PINTEREST_AD_ACCOUNT_ID not configured' }, { status: 500 });
32  }
33
34  const endDate = searchParams.get('endDate') || new Date().toISOString().split('T')[0];
35  const startDate = searchParams.get('startDate') ||
36    new Date(Date.now() - 30 * 86400000).toISOString().split('T')[0];
37
38  try {
39    const [campaignsData, analyticsData] = await Promise.all([
40      pinterestFetch<{ items: PinterestCampaign[] }>(
41        `ad_accounts/${adAccountId}/campaigns`,
42        { params: { page_size: '100' } }
43      ),
44      pinterestFetch<PinterestCampaignAnalytic[]>(
45        `ad_accounts/${adAccountId}/campaigns/analytics`,
46        {
47          params: {
48            start_date: startDate,
49            end_date: endDate,
50            columns: [
51              'SPEND_IN_DOLLAR',
52              'IMPRESSION_1',
53              'CLICK_2',
54              'SAVE',
55              'SAVE_RATE',
56              'OUTBOUND_CLICK',
57              'CHECKOUT_ROAS',
58            ].join(','),
59            granularity: 'TOTAL',
60          },
61        }
62      ),
63    ]);
64
65    const analyticsMap = new Map<string, PinterestCampaignAnalytic>();
66    (Array.isArray(analyticsData) ? analyticsData : []).forEach((row) => {
67      analyticsMap.set(row.campaign_id, row);
68    });
69
70    const campaigns = (campaignsData.items || []).map((campaign) => {
71      const metrics = analyticsMap.get(campaign.id);
72      return {
73        id: campaign.id,
74        name: campaign.name,
75        status: campaign.status,
76        objective: campaign.objective_type,
77        dailyBudget: campaign.daily_spend_cap ? campaign.daily_spend_cap / 1_000_000 : null,
78        spend: metrics?.SPEND_IN_DOLLAR ?? 0,
79        impressions: metrics?.IMPRESSION_1 ?? 0,
80        clicks: metrics?.CLICK_2 ?? 0,
81        saves: metrics?.SAVE ?? 0,
82        saveRate: metrics?.SAVE_RATE ?? 0,
83        outboundClicks: metrics?.OUTBOUND_CLICK ?? 0,
84        roas: metrics?.CHECKOUT_ROAS ?? null,
85      };
86    });
87
88    campaigns.sort((a, b) => b.spend - a.spend);
89
90    const totals = campaigns.reduce(
91      (acc, c) => ({
92        spend: acc.spend + c.spend,
93        impressions: acc.impressions + c.impressions,
94        clicks: acc.clicks + c.clicks,
95        saves: acc.saves + c.saves,
96      }),
97      { spend: 0, impressions: 0, clicks: 0, saves: 0 }
98    );
99
100    return NextResponse.json({ campaigns, totals, dateRange: { startDate, endDate } });
101  } catch (err) {
102    const message = err instanceof Error ? err.message : 'Failed to fetch Pinterest campaigns';
103    return NextResponse.json({ error: message }, { status: 500 });
104  }
105}

1// components/PinterestTag.tsx
2'use client';
3
4import Script from 'next/script';
5
6declare global {
7  interface Window {
8    pintrk?: (...args: unknown[]) => void;
9  }
10}
11
12export function PinterestTag() {
13  const tagId = process.env.NEXT_PUBLIC_PINTEREST_TAG_ID;
14  if (!tagId) return null;
15
16  return (
17    <>
18      <Script
19        id="pinterest-tag"
20        strategy="afterInteractive"
21        dangerouslySetInnerHTML={{
22          __html: `
23            !function(e){
24              if(!window.pintrk){
25                window.pintrk = function () {
26                  window.pintrk.queue.push(Array.prototype.slice.call(arguments))
27                };
28                var n=window.pintrk;
29                n.version="3.0",n.queue=[];
30                var t=document.createElement("script");
31                t.async=!0,t.src=e;
32                var r=document.getElementsByTagName("script")[0];
33                r.parentNode.insertBefore(t,r)
34              }
35            }("https://s.pinimg.com/ct/core.js");
36            pintrk('load', '${tagId}', { em: '' });
37            pintrk('page');
38          `,
39        }}
40      />
41      <noscript>
42        <img
43          height="1"
44          width="1"
45          style={{ display: 'none' }}
46          alt=""
47          src={`https://ct.pinterest.com/v3/?event=init&tid=${tagId}&pd[em]=&noscript=1`}
48        />
49      </noscript>
50    </>
51  );
52}