How to Integrate Bolt.new with Zoom

1// .env.local
2ZOOM_ACCOUNT_ID=your_account_id_here
3ZOOM_CLIENT_ID=your_client_id_here
4ZOOM_CLIENT_SECRET=your_client_secret_here

1// lib/zoom.ts
2let cachedToken: { token: string; expiresAt: number } | null = null;
3
4export async function getZoomToken(): Promise<string> {
5  if (cachedToken && Date.now() < cachedToken.expiresAt - 60_000) {
6    return cachedToken.token;
7  }
8
9  const accountId = process.env.ZOOM_ACCOUNT_ID!;
10  const clientId = process.env.ZOOM_CLIENT_ID!;
11  const clientSecret = process.env.ZOOM_CLIENT_SECRET!;
12  const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
13
14  const response = await fetch(
15    `https://zoom.us/oauth/token?grant_type=account_credentials&account_id=${accountId}`,
16    {
17      method: 'POST',
18      headers: { Authorization: `Basic ${credentials}` },
19    }
20  );
21
22  if (!response.ok) {
23    throw new Error(`Zoom token request failed: ${response.status}`);
24  }
25
26  const data = await response.json();
27  cachedToken = {
28    token: data.access_token,
29    expiresAt: Date.now() + data.expires_in * 1000,
30  };
31  return cachedToken.token;
32}
33
34// app/api/zoom/meetings/create/route.ts
35import { NextRequest, NextResponse } from 'next/server';
36import { getZoomToken } from '@/lib/zoom';
37
38export async function POST(request: NextRequest) {
39  const { topic, startTime, durationMinutes, hostEmail } = await request.json();
40  const token = await getZoomToken();
41
42  const response = await fetch(
43    `https://api.zoom.us/v2/users/${hostEmail ?? 'me'}/meetings`,
44    {
45      method: 'POST',
46      headers: {
47        Authorization: `Bearer ${token}`,
48        'Content-Type': 'application/json',
49      },
50      body: JSON.stringify({
51        topic,
52        type: 2, // Scheduled meeting
53        start_time: startTime,
54        duration: durationMinutes ?? 60,
55        timezone: 'UTC',
56        settings: {
57          waiting_room: false,
58          join_before_host: true,
59          auto_recording: 'none',
60        },
61      }),
62    }
63  );
64
65  if (!response.ok) {
66    const error = await response.json();
67    return NextResponse.json({ error }, { status: response.status });
68  }
69
70  const meeting = await response.json();
71  return NextResponse.json({
72    meetingId: meeting.id,
73    joinUrl: meeting.join_url,
74    startUrl: meeting.start_url,
75    password: meeting.password,
76    startTime: meeting.start_time,
77  });
78}

1// app/api/zoom/recordings/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { getZoomToken } from '@/lib/zoom';
4
5export async function GET(request: NextRequest) {
6  const { searchParams } = new URL(request.url);
7  const userId = searchParams.get('userId') ?? 'me';
8
9  // Default: last 30 days
10  const to = new Date().toISOString().split('T')[0];
11  const fromDate = new Date();
12  fromDate.setDate(fromDate.getDate() - 30);
13  const from = fromDate.toISOString().split('T')[0];
14
15  const token = await getZoomToken();
16
17  const response = await fetch(
18    `https://api.zoom.us/v2/users/${userId}/recordings?from=${from}&to=${to}&page_size=50`,
19    { headers: { Authorization: `Bearer ${token}` } }
20  );
21
22  if (!response.ok) {
23    return NextResponse.json({ error: `Zoom API error: ${response.status}` }, { status: response.status });
24  }
25
26  const data = await response.json();
27
28  const recordings = (data.meetings ?? []).map((meeting: Record<string, unknown>) => ({
29    meetingId: meeting.id,
30    topic: meeting.topic,
31    startTime: meeting.start_time,
32    duration: meeting.duration,
33    totalSize: meeting.total_size,
34    files: (meeting.recording_files as Array<Record<string, unknown>>)
35      ?.filter((f) => f.file_type === 'MP4')
36      .map((f) => ({
37        id: f.id,
38        playUrl: f.play_url,
39        downloadUrl: f.download_url,
40        fileSize: f.file_size,
41      })),
42  }));
43
44  return NextResponse.json({ recordings, totalRecords: data.total_records });
45}

1// app/api/zoom/webhook/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import crypto from 'crypto';
4
5const WEBHOOK_SECRET = process.env.ZOOM_WEBHOOK_SECRET!;
6
7function verifyZoomWebhook(request: NextRequest, body: string): boolean {
8  const timestamp = request.headers.get('x-zm-request-timestamp');
9  const signature = request.headers.get('x-zm-signature');
10  if (!timestamp || !signature) return false;
11
12  const message = `v0:${timestamp}:${body}`;
13  const hash = crypto.createHmac('sha256', WEBHOOK_SECRET).update(message).digest('hex');
14  const expectedSignature = `v0=${hash}`;
15  return crypto.timingSafeEqual(
16    Buffer.from(signature),
17    Buffer.from(expectedSignature)
18  );
19}
20
21export async function POST(request: NextRequest) {
22  const rawBody = await request.text();
23
24  if (!verifyZoomWebhook(request, rawBody)) {
25    return NextResponse.json({ error: 'Invalid signature' }, { status: 401 });
26  }
27
28  const payload = JSON.parse(rawBody);
29
30  // Handle URL validation challenge
31  if (payload.event === 'endpoint.url_validation') {
32    const hash = crypto
33      .createHmac('sha256', WEBHOOK_SECRET)
34      .update(payload.payload.plainToken)
35      .digest('hex');
36    return NextResponse.json({
37      plainToken: payload.payload.plainToken,
38      encryptedToken: hash,
39    });
40  }
41
42  // Handle meeting ended event
43  if (payload.event === 'meeting.ended') {
44    const { id, topic, end_time } = payload.payload.object;
45    console.log(`Meeting ended: ${id} (${topic}) at ${end_time}`);
46    // Add your database update or notification logic here
47  }
48
49  return NextResponse.json({ received: true });
50}