How to Integrate Bolt.new with GetResponse

1// lib/getresponse.ts
2const API_BASE = 'https://api.getresponse.com';
3
4interface RequestOptions {
5  method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
6  body?: unknown;
7  queryParams?: Record<string, string | number>;
8}
9
10export interface GetResponseContact {
11  contactId?: string;
12  name: string;
13  email: string;
14  campaign?: { campaignId: string };
15  tags?: Array<{ tagId?: string; name?: string }>;
16  customFieldValues?: Array<{ customFieldId: string; value: string[] }>;
17  dayOfCycle?: number;
18  createdOn?: string;
19  subscriptionConfirmedOn?: string;
20}
21
22export interface GetResponseList {
23  campaignId: string;
24  name: string;
25  totalSubscribers?: number;
26  description?: string;
27}
28
29async function getResponseRequest<T>(path: string, options: RequestOptions = {}): Promise<T> {
30  const apiKey = process.env.GETRESPONSE_API_KEY;
31  if (!apiKey) throw new Error('GETRESPONSE_API_KEY is not set');
32
33  const url = new URL(`${API_BASE}${path}`);
34  if (options.queryParams) {
35    for (const [key, value] of Object.entries(options.queryParams)) {
36      url.searchParams.set(key, String(value));
37    }
38  }
39
40  const response = await fetch(url.toString(), {
41    method: options.method || 'GET',
42    headers: {
43      'X-Auth-Token': `api-key ${apiKey}`,
44      'Content-Type': 'application/json',
45    },
46    ...(options.body ? { body: JSON.stringify(options.body) } : {}),
47  });
48
49  if (response.status === 204) return null as T;
50  const data = await response.json();
51
52  if (!response.ok) {
53    const message = data.message || data.codeDescription || `GetResponse API error ${response.status}`;
54    const error = new Error(message) as Error & { statusCode: number };
55    error.statusCode = response.status;
56    throw error;
57  }
58
59  return data as T;
60}
61
62export async function createContact(
63  email: string,
64  name: string,
65  listId?: string,
66  tags?: string[]
67): Promise<void> {
68  const campaignId = listId || process.env.GETRESPONSE_LIST_ID;
69  if (!campaignId) throw new Error('GetResponse list ID is required');
70
71  const body: Record<string, unknown> = {
72    email,
73    name: name || email,
74    campaign: { campaignId },
75    dayOfCycle: 0,
76  };
77
78  if (tags?.length) {
79    body.tags = tags.map((name) => ({ name }));
80  }
81
82  await getResponseRequest('/v3/contacts', { method: 'POST', body });
83}
84
85export async function getContacts(
86  listId?: string,
87  page = 1,
88  perPage = 50
89): Promise<GetResponseContact[]> {
90  const params: Record<string, string | number> = { page, perPage };
91  if (listId) params['query[campaignId]'] = listId;
92
93  return getResponseRequest<GetResponseContact[]>('/v3/contacts', { queryParams: params });
94}
95
96export async function getContactByEmail(email: string): Promise<GetResponseContact | null> {
97  const contacts = await getResponseRequest<GetResponseContact[]>('/v3/contacts', {
98    queryParams: { 'query[email]': email },
99  });
100  return contacts?.[0] || null;
101}
102
103export async function updateContact(
104  contactId: string,
105  data: Partial<GetResponseContact>
106): Promise<void> {
107  await getResponseRequest(`/v3/contacts/${contactId}`, { method: 'PATCH', body: data });
108}
109
110export async function getLists(): Promise<GetResponseList[]> {
111  return getResponseRequest<GetResponseList[]>('/v3/campaigns');
112}

1// app/api/getresponse/subscribe/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { createContact } from '@/lib/getresponse';
4
5const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
6
7export async function POST(request: NextRequest) {
8  const body = await request.json();
9  const { email, name, listId, tags } = body;
10
11  if (!email || !emailRegex.test(email)) {
12    return NextResponse.json({ error: 'Valid email address is required' }, { status: 400 });
13  }
14
15  try {
16    await createContact(email, name || email, listId, tags);
17    return NextResponse.json({ success: true, subscribed: true }, { status: 201 });
18  } catch (error) {
19    const err = error as Error & { statusCode?: number };
20
21    // 409 means the contact already exists in the list
22    if (err.statusCode === 409) {
23      return NextResponse.json({ success: true, alreadySubscribed: true });
24    }
25
26    console.error('GetResponse subscribe error:', err.message);
27    return NextResponse.json(
28      { error: 'Failed to subscribe. Please try again.' },
29      { status: 500 }
30    );
31  }
32}

1// app/api/getresponse/contacts/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { getContacts } from '@/lib/getresponse';
4
5export async function GET(request: NextRequest) {
6  const { searchParams } = new URL(request.url);
7  const listId = searchParams.get('listId') || process.env.GETRESPONSE_LIST_ID || undefined;
8  const page = parseInt(searchParams.get('page') || '1', 10);
9  const perPage = Math.min(parseInt(searchParams.get('perPage') || '50', 10), 100);
10
11  try {
12    const contacts = await getContacts(listId, page, perPage);
13    return NextResponse.json({
14      contacts,
15      page,
16      perPage,
17      hasMore: contacts.length === perPage,
18    });
19  } catch (error) {
20    return NextResponse.json(
21      { error: (error as Error).message },
22      { status: 500 }
23    );
24  }
25}
26
27// app/api/getresponse/lists/route.ts
28// (create as a separate file)
29import { NextResponse } from 'next/server';
30import { getLists } from '@/lib/getresponse';
31
32export async function GET() {
33  try {
34    const lists = await getLists();
35    return NextResponse.json(lists);
36  } catch (error) {
37    return NextResponse.json(
38      { error: (error as Error).message },
39      { status: 500 }
40    );
41  }
42}

1// app/api/getresponse/webhook/route.ts
2// NOTE: GetResponse webhooks require a publicly accessible URL.
3// Deploy to Netlify first, then configure in GetResponse Tools → Integrations → Webhooks.
4import { NextRequest, NextResponse } from 'next/server';
5
6interface GetResponseWebhookPayload {
7  action: string;
8  contact?: {
9    contactId: string;
10    email: string;
11    name: string;
12  };
13  newsletter?: {
14    newsletterId: string;
15    subject: string;
16  };
17  clickedUrl?: string;
18  occurredAt?: string;
19}
20
21export async function POST(request: NextRequest) {
22  let payload: GetResponseWebhookPayload;
23  try {
24    payload = await request.json();
25  } catch {
26    return NextResponse.json({ error: 'Invalid JSON' }, { status: 400 });
27  }
28
29  const { action, contact } = payload;
30  const email = contact?.email;
31
32  switch (action) {
33    case 'subscribe':
34      console.log(`GetResponse: New subscriber — ${email}`);
35      // TODO: Create user record in your database if needed
36      break;
37
38    case 'unsubscribe':
39      console.log(`GetResponse: Unsubscribe — ${email}`);
40      // TODO: Update subscription status in Supabase
41      break;
42
43    case 'email_open':
44      console.log(`GetResponse: Email opened by ${email} — ${payload.newsletter?.subject}`);
45      break;
46
47    case 'click':
48      console.log(`GetResponse: Link clicked by ${email}: ${payload.clickedUrl}`);
49      break;
50
51    default:
52      console.log(`GetResponse unhandled webhook action: ${action}`);
53  }
54
55  return NextResponse.json({ received: true });
56}