How to Integrate Bolt.new with LeadSquared

1// lib/leadsquared.ts
2export interface LeadSquaredLead {
3  ProspectID?: string;
4  FirstName: string;
5  LastName: string;
6  EmailAddress: string;
7  Phone?: string;
8  Mobile?: string;
9  Company?: string;
10  Source?: string;
11  Description?: string;
12  ProspectStage?: string;
13  ProspectScore?: number;
14  OwnerIdEmail?: string;
15  [key: string]: string | number | undefined;
16}
17
18export interface LeadSquaredActivity {
19  RelatedProspectId: string;
20  ActivityEvent: number; // 200-999 range for custom events, standard = 1-199
21  ActivityNote?: string;
22  ActivityDateTime?: string;
23}
24
25interface ApiOptions {
26  method?: 'GET' | 'POST';
27  body?: unknown;
28  queryParams?: Record<string, string | number>;
29}
30
31async function apiRequest<T>(path: string, options: ApiOptions = {}): Promise<T> {
32  const accessKey = process.env.LEADSQUARED_ACCESS_KEY;
33  const secretKey = process.env.LEADSQUARED_SECRET_KEY;
34  const apiHost = process.env.LEADSQUARED_API_HOST || 'api.leadsquared.com';
35
36  if (!accessKey || !secretKey) {
37    throw new Error('LeadSquared credentials not configured');
38  }
39
40  const url = new URL(`https://${apiHost}/${path}`);
41  if (options.queryParams) {
42    for (const [key, value] of Object.entries(options.queryParams)) {
43      url.searchParams.set(key, String(value));
44    }
45  }
46
47  const response = await fetch(url.toString(), {
48    method: options.method || 'GET',
49    headers: {
50      'Content-Type': 'application/json',
51      'x-LSQ-AccessKey': accessKey,
52      'x-LSQ-SecretKey': secretKey,
53    },
54    ...(options.body ? { body: JSON.stringify(options.body) } : {}),
55  });
56
57  const text = await response.text();
58  if (!response.ok) {
59    throw new Error(`LeadSquared API error ${response.status}: ${text}`);
60  }
61
62  if (!text) return null as T;
63
64  try {
65    return JSON.parse(text) as T;
66  } catch {
67    return text as unknown as T;
68  }
69}
70
71export async function createLead(leadData: Partial<LeadSquaredLead>): Promise<{ Message: string; ProspectID?: string }> {
72  return apiRequest('v2/LeadManagement.svc/Lead.Create', {
73    method: 'POST',
74    body: leadData,
75  });
76}
77
78export async function getLeads(
79  page = 1,
80  size = 50,
81  searchBy?: string
82): Promise<LeadSquaredLead[]> {
83  const params: Record<string, string | number> = { Page: page, Size: size };
84  if (searchBy) params.SearchText = searchBy;
85
86  const result = await apiRequest<{ ProspectList: LeadSquaredLead[] }>(
87    'v2/LeadManagement.svc/Leads.GetAll',
88    { queryParams: params }
89  );
90  return result?.ProspectList || [];
91}
92
93export async function getLeadByEmail(email: string): Promise<LeadSquaredLead | null> {
94  const leads = await apiRequest<LeadSquaredLead[]>(
95    'v2/LeadManagement.svc/Lead.GetByEmailAddress',
96    { queryParams: { emailaddress: email } }
97  );
98  return Array.isArray(leads) ? leads[0] : null;
99}
100
101export async function updateLead(
102  prospectId: string,
103  fields: Partial<LeadSquaredLead>
104): Promise<void> {
105  await apiRequest('v2/LeadManagement.svc/Lead.Update', {
106    method: 'POST',
107    body: { ProspectID: prospectId, ...fields },
108  });
109}

1// app/api/leadsquared/capture/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { createLead, updateLead, getLeadByEmail } from '@/lib/leadsquared';
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, company, source, message, customFields } = body;
10
11  if (!firstName?.trim()) return NextResponse.json({ error: 'First name required' }, { status: 400 });
12  if (!lastName?.trim()) return NextResponse.json({ error: 'Last name required' }, { status: 400 });
13  if (!email || !emailRegex.test(email)) {
14    return NextResponse.json({ error: 'Valid email required' }, { status: 400 });
15  }
16
17  const leadData: Record<string, string> = {
18    FirstName: firstName.trim(),
19    LastName: lastName.trim(),
20    EmailAddress: email.toLowerCase().trim(),
21    Source: source || 'Web Form',
22  };
23
24  if (phone) leadData.Phone = phone.trim();
25  if (company) leadData.Company = company.trim();
26  if (message) leadData.Description = message.trim();
27
28  // Map custom fields with mx_ prefix
29  if (customFields && typeof customFields === 'object') {
30    for (const [key, value] of Object.entries(customFields)) {
31      if (typeof value === 'string') {
32        leadData[`mx_${key}`] = value;
33      }
34    }
35  }
36
37  try {
38    const existing = await getLeadByEmail(email);
39
40    if (existing?.ProspectID) {
41      await updateLead(existing.ProspectID, leadData);
42      return NextResponse.json({ success: true, action: 'updated', prospectId: existing.ProspectID });
43    } else {
44      const result = await createLead(leadData);
45      return NextResponse.json({ success: true, action: 'created', prospectId: result?.ProspectID }, { status: 201 });
46    }
47  } catch (error) {
48    console.error('LeadSquared capture error:', error);
49    return NextResponse.json({ error: 'Failed to save lead' }, { status: 500 });
50  }
51}

1// app/api/leadsquared/leads/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { getLeads } from '@/lib/leadsquared';
4
5export async function GET(request: NextRequest) {
6  const { searchParams } = new URL(request.url);
7  const page = parseInt(searchParams.get('page') || '1', 10);
8  const size = parseInt(searchParams.get('size') || '25', 10);
9  const search = searchParams.get('q') || undefined;
10
11  try {
12    const leads = await getLeads(page, Math.min(size, 100), search);
13    return NextResponse.json({ leads, page, size });
14  } catch (error) {
15    return NextResponse.json(
16      { error: (error as Error).message },
17      { status: 500 }
18    );
19  }
20}
21
22// app/api/leadsquared/leads/[id]/activities/route.ts
23// (create as a separate file)
24import { NextRequest, NextResponse } from 'next/server';
25
26async function getLeadActivities(prospectId: string) {
27  const accessKey = process.env.LEADSQUARED_ACCESS_KEY!;
28  const secretKey = process.env.LEADSQUARED_SECRET_KEY!;
29  const apiHost = process.env.LEADSQUARED_API_HOST || 'api.leadsquared.com';
30
31  const url = `https://${apiHost}/v2/ProspectActivity.svc/ProspectActivity.GetByProspectId?prospectId=${prospectId}&pageIndex=1&pageSize=20`;
32
33  const response = await fetch(url, {
34    headers: {
35      'x-LSQ-AccessKey': accessKey,
36      'x-LSQ-SecretKey': secretKey,
37    },
38  });
39
40  if (!response.ok) throw new Error(`LeadSquared API error: ${response.status}`);
41  return response.json();
42}
43
44export async function GET(
45  request: NextRequest,
46  { params }: { params: { id: string } }
47) {
48  try {
49    const activities = await getLeadActivities(params.id);
50    return NextResponse.json(activities);
51  } catch (error) {
52    return NextResponse.json(
53      { error: (error as Error).message },
54      { status: 500 }
55    );
56  }
57}

1// app/api/leadsquared/webhook/route.ts
2// NOTE: LeadSquared webhooks require a publicly accessible URL.
3// Deploy to Netlify first, then configure in LeadSquared Settings → Webhooks.
4import { NextRequest, NextResponse } from 'next/server';
5
6export async function POST(request: NextRequest) {
7  const contentType = request.headers.get('content-type') || '';
8
9  let payload: Record<string, unknown>;
10
11  try {
12    if (contentType.includes('application/x-www-form-urlencoded')) {
13      const text = await request.text();
14      const params = new URLSearchParams(text);
15      payload = Object.fromEntries(params.entries());
16    } else {
17      payload = await request.json();
18    }
19  } catch {
20    return NextResponse.json({ error: 'Invalid payload' }, { status: 400 });
21  }
22
23  const eventType = payload.event_type as string || payload.EventType as string || 'unknown';
24  const prospectId = payload.ProspectID as string || payload.prospect_id as string;
25  const email = payload.EmailAddress as string || payload.email as string;
26
27  console.log(`LeadSquared webhook: ${eventType}`, { prospectId, email });
28
29  switch (eventType) {
30    case 'LeadStageChanged':
31    case 'lead.stage_changed':
32      console.log(`Lead ${email} stage changed to: ${payload.ProspectStage || payload.new_stage}`);
33      // TODO: Update lead stage in Supabase if syncing lead data
34      break;
35
36    case 'ActivityAdded':
37    case 'lead.activity_added':
38      console.log(`Activity added for lead: ${email}`);
39      break;
40
41    case 'LeadCreated':
42    case 'lead.created':
43      console.log(`New LeadSquared lead created: ${email}`);
44      break;
45
46    default:
47      console.log(`Unhandled LeadSquared webhook: ${eventType}`);
48  }
49
50  return NextResponse.json({ received: true });
51}