How to Integrate Bolt.new with Keap

1// lib/keap.ts
2const API_URL = process.env.KEAP_API_URL || 'https://api.infusionsoft.com/crm/rest';
3
4export interface KeapEmailAddress {
5  field: 'EMAIL1' | 'EMAIL2' | 'EMAIL3';
6  email: string;
7}
8
9export interface KeapPhoneNumber {
10  field: 'PHONE1' | 'PHONE2' | 'PHONE3';
11  number: string;
12  type?: string;
13}
14
15export interface KeapContact {
16  id?: number;
17  given_name?: string;
18  family_name?: string;
19  email_addresses?: KeapEmailAddress[];
20  phone_numbers?: KeapPhoneNumber[];
21  tag_ids?: number[];
22  source_type?: string;
23  lead_source_id?: number;
24  custom_fields?: Array<{ id: number; content: unknown }>;
25}
26
27async function keapRequest<T>(
28  path: string,
29  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' = 'GET',
30  body?: unknown
31): Promise<T> {
32  const token = process.env.KEAP_ACCESS_TOKEN;
33  if (!token) throw new Error('KEAP_ACCESS_TOKEN is not set');
34
35  const response = await fetch(`${API_URL}${path}`, {
36    method,
37    headers: {
38      'Authorization': `Bearer ${token}`,
39      'Content-Type': 'application/json',
40    },
41    ...(body ? { body: JSON.stringify(body) } : {}),
42  });
43
44  if (response.status === 204) return null as T;
45  const data = await response.json();
46  if (!response.ok) {
47    throw new Error(data.message || `Keap API error: ${response.status}`);
48  }
49  return data as T;
50}
51
52export async function findContactByEmail(email: string): Promise<KeapContact | null> {
53  const result = await keapRequest<{ contacts: KeapContact[] }>(
54    `/v1/contacts?email=${encodeURIComponent(email)}&fields=id,given_name,family_name,email_addresses,tag_ids`
55  );
56  return result.contacts?.[0] || null;
57}
58
59export async function createContact(contact: KeapContact): Promise<KeapContact> {
60  return keapRequest<KeapContact>('/v1/contacts', 'POST', contact);
61}
62
63export async function updateContact(id: number, data: Partial<KeapContact>): Promise<KeapContact> {
64  return keapRequest<KeapContact>(`/v1/contacts/${id}`, 'PATCH', data);
65}
66
67export async function applyTag(contactId: number, tagId: number): Promise<void> {
68  await keapRequest(`/v1/contacts/${contactId}/tags`, 'POST', { tagIds: [tagId] });
69}
70
71export async function createNote(
72  contactId: number,
73  title: string,
74  body: string
75): Promise<void> {
76  await keapRequest('/v1/notes', 'POST', {
77    contact_id: contactId,
78    title,
79    body,
80    type: 'Other',
81  });
82}

1// app/api/keap/leads/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { findContactByEmail, createContact, updateContact, applyTag } from '@/lib/keap';
4
5const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
6
7export async function POST(request: NextRequest) {
8  const body = await request.json();
9  const { firstName, lastName, email, phone, source } = body;
10
11  if (!firstName?.trim()) return NextResponse.json({ error: 'First name is required' }, { status: 400 });
12  if (!lastName?.trim()) return NextResponse.json({ error: 'Last name is required' }, { status: 400 });
13  if (!email || !emailRegex.test(email)) {
14    return NextResponse.json({ error: 'Valid email is required' }, { status: 400 });
15  }
16
17  const contactData = {
18    given_name: firstName.trim(),
19    family_name: lastName.trim(),
20    email_addresses: [{ field: 'EMAIL1' as const, email: email.toLowerCase().trim() }],
21    ...(phone ? { phone_numbers: [{ field: 'PHONE1' as const, number: phone.trim(), type: 'Work' }] } : {}),
22    ...(source ? { source_type: source } : {}),
23  };
24
25  try {
26    const existing = await findContactByEmail(email);
27    let contactId: number;
28    let action: 'created' | 'updated';
29
30    if (existing?.id) {
31      await updateContact(existing.id, contactData);
32      contactId = existing.id;
33      action = 'updated';
34    } else {
35      const created = await createContact(contactData);
36      contactId = created.id!;
37      action = 'created';
38    }
39
40    // Apply new lead tag to trigger Keap automation
41    const tagId = process.env.KEAP_NEW_LEAD_TAG_ID;
42    if (tagId && contactId) {
43      try {
44        await applyTag(contactId, parseInt(tagId, 10));
45      } catch (tagError) {
46        console.error('Keap tag application failed (non-critical):', tagError);
47      }
48    }
49
50    const statusCode = action === 'created' ? 201 : 200;
51    return NextResponse.json({ success: true, action, contactId }, { status: statusCode });
52  } catch (error) {
53    console.error('Keap lead creation error:', error);
54    return NextResponse.json({ error: 'Failed to save contact' }, { status: 500 });
55  }
56}

1// app/api/keap/callback/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { createClient } from '@supabase/supabase-js';
4
5export async function GET(request: NextRequest) {
6  const { searchParams } = new URL(request.url);
7  const code = searchParams.get('code');
8  const error = searchParams.get('error');
9
10  if (error || !code) {
11    return NextResponse.redirect(new URL('/settings?error=keap_auth_failed', request.url));
12  }
13
14  const redirectUri = `${process.env.NEXT_PUBLIC_APP_URL}/api/keap/callback`;
15
16  const tokenResponse = await fetch('https://api.infusionsoft.com/token', {
17    method: 'POST',
18    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
19    body: new URLSearchParams({
20      grant_type: 'authorization_code',
21      client_id: process.env.KEAP_CLIENT_ID!,
22      client_secret: process.env.KEAP_CLIENT_SECRET!,
23      redirect_uri: redirectUri,
24      code,
25    }),
26  });
27
28  if (!tokenResponse.ok) {
29    console.error('Keap token exchange failed:', await tokenResponse.text());
30    return NextResponse.redirect(new URL('/settings?error=keap_token_failed', request.url));
31  }
32
33  const tokens = await tokenResponse.json();
34  const expiresAt = new Date(Date.now() + tokens.expires_in * 1000).toISOString();
35
36  const supabase = createClient(
37    process.env.NEXT_PUBLIC_SUPABASE_URL!,
38    process.env.SUPABASE_SERVICE_ROLE_KEY!
39  );
40
41  // Store tokens — in production, associate with the current user's ID
42  await supabase.from('keap_tokens').upsert({
43    access_token: tokens.access_token,
44    refresh_token: tokens.refresh_token,
45    expires_at: expiresAt,
46  }, { onConflict: 'user_id' }); // adjust based on your auth model
47
48  return NextResponse.redirect(new URL('/dashboard?connected=keap', request.url));
49}

1# netlify.toml
2[build]
3  command = "npm run build"
4  publish = ".next"
5
6[[plugins]]
7  package = "@netlify/plugin-nextjs"
8
9[build.environment]
10  NODE_VERSION = "20"
11  NEXT_TELEMETRY_DISABLED = "1"