How to Integrate Bolt.new with Sinch

1# Sinch SMS API authentication (HTTP Basic Auth):
2# Username: Service Plan ID (UUID from SMS → Service Plans)
3# Password: API Token (long alphanumeric string)
4
5# Sinch SMS API base URL:
6# US: https://us.sms.api.sinch.com/xms/v1/{servicePlanId}/
7# EU: https://eu.sms.api.sinch.com/xms/v1/{servicePlanId}/
8
9# Sinch Verification API base URL:
10# https://verificationapi-v1.sinch.com/verification/v1/
11# Auth: Basic {base64(app_key:app_secret)}

1// lib/sinch.ts
2const SERVICE_PLAN_ID = process.env.SINCH_SERVICE_PLAN_ID!;
3const API_TOKEN = process.env.SINCH_API_TOKEN!;
4const VERIFICATION_APP_KEY = process.env.SINCH_VERIFICATION_APP_KEY!;
5const VERIFICATION_APP_SECRET = process.env.SINCH_VERIFICATION_APP_SECRET!;
6
7export const SINCH_SENDER = process.env.SINCH_SENDER_NUMBER!;
8const SMS_BASE = `https://us.sms.api.sinch.com/xms/v1/${SERVICE_PLAN_ID}`;
9const VERIFICATION_BASE = 'https://verificationapi-v1.sinch.com/verification/v1';
10
11function basicAuth(user: string, pass: string): string {
12  return 'Basic ' + Buffer.from(`${user}:${pass}`).toString('base64');
13}
14
15export async function sinchSMSFetch<T>(path: string, method = 'GET', body?: object): Promise<T> {
16  const response = await fetch(`${SMS_BASE}${path}`, {
17    method,
18    headers: {
19      Authorization: basicAuth(SERVICE_PLAN_ID, API_TOKEN),
20      'Content-Type': 'application/json',
21    },
22    body: body ? JSON.stringify(body) : undefined,
23  });
24  if (!response.ok) {
25    const text = await response.text();
26    throw new Error(`Sinch SMS ${response.status}: ${text}`);
27  }
28  return response.json() as Promise<T>;
29}
30
31export async function sinchVerificationFetch<T>(path: string, method = 'POST', body?: object): Promise<T> {
32  const response = await fetch(`${VERIFICATION_BASE}${path}`, {
33    method,
34    headers: {
35      Authorization: basicAuth(VERIFICATION_APP_KEY, VERIFICATION_APP_SECRET),
36      'Content-Type': 'application/json',
37    },
38    body: body ? JSON.stringify(body) : undefined,
39  });
40  if (!response.ok) {
41    const text = await response.text();
42    throw new Error(`Sinch Verification ${response.status}: ${text}`);
43  }
44  return response.json() as Promise<T>;
45}

1// app/api/sinch/send-sms/route.ts
2import { NextResponse } from 'next/server';
3import { sinchSMSFetch, SINCH_SENDER } from '@/lib/sinch';
4
5interface SinchBatch {
6  id: string;
7  type: string;
8  status: string;
9  to: string[];
10  from: string;
11  created_at: string;
12}
13
14const E164_REGEX = /^\+[1-9]\d{1,14}$/;
15
16export async function POST(request: Request) {
17  try {
18    const { to, message } = await request.json();
19    const recipients = Array.isArray(to) ? to : [to];
20
21    const invalidNumbers = recipients.filter((n: string) => !E164_REGEX.test(n));
22    if (invalidNumbers.length > 0) {
23      return NextResponse.json(
24        { error: `Invalid phone numbers: ${invalidNumbers.join(', ')}` },
25        { status: 400 }
26      );
27    }
28
29    if (!message || message.trim().length === 0) {
30      return NextResponse.json({ error: 'Message cannot be empty' }, { status: 400 });
31    }
32
33    const batch = await sinchSMSFetch<SinchBatch>('/batches', 'POST', {
34      from: SINCH_SENDER,
35      to: recipients,
36      body: message,
37    });
38
39    return NextResponse.json({
40      batchId: batch.id,
41      status: batch.status,
42      recipients: batch.to.length,
43    });
44  } catch (error: unknown) {
45    const e = error as { message: string };
46    return NextResponse.json({ error: e.message }, { status: 500 });
47  }
48}

1// app/api/sinch/verify/start/route.ts
2import { NextResponse } from 'next/server';
3import { sinchVerificationFetch } from '@/lib/sinch';
4
5export async function POST(request: Request) {
6  try {
7    const { phoneNumber } = await request.json();
8
9    const result = await sinchVerificationFetch('/verifications/number', 'POST', {
10      identity: { type: 'number', endpoint: phoneNumber },
11      method: 'sms',
12    });
13
14    return NextResponse.json({ status: 'pending', result });
15  } catch (error: unknown) {
16    const e = error as { message: string };
17    return NextResponse.json({ error: e.message }, { status: 500 });
18  }
19}
20
21// app/api/sinch/verify/check/route.ts
22export async function POST(request: Request) {
23  try {
24    const { phoneNumber, code } = await request.json();
25    const encoded = encodeURIComponent(phoneNumber);
26
27    const result = await sinchVerificationFetch<{ status: string }>(
28      `/verifications/number/${encoded}`,
29      'PUT',
30      { sms: { code } }
31    );
32
33    const verified = result.status === 'SUCCESSFUL';
34    return NextResponse.json({ verified, status: result.status });
35  } catch (error: unknown) {
36    const e = error as { message: string };
37    return NextResponse.json({ error: e.message }, { status: 500 });
38  }
39}

1// app/api/sinch/incoming/route.ts
2import { NextResponse } from 'next/server';
3
4interface SinchInboundMessage {
5  type: 'mo_text' | 'mo_binary';
6  from: string;
7  to: string;
8  body: string;
9  id: string;
10  received_at: string;
11}
12
13export async function POST(request: Request) {
14  try {
15    const message = await request.json() as SinchInboundMessage;
16
17    console.log(`Inbound SMS from ${message.from}: ${message.body}`);
18    // Save to database:
19    // await supabase.from('messages').insert({
20    //   from_number: message.from,
21    //   body: message.body,
22    //   sinch_id: message.id,
23    //   received_at: message.received_at,
24    // });
25
26    // Return 200 quickly — Sinch retries if it doesn't receive 200
27    return NextResponse.json({ status: 'ok' });
28  } catch (error: unknown) {
29    const e = error as { message: string };
30    console.error('Sinch webhook error:', e.message);
31    return NextResponse.json({ status: 'ok' }); // Return 200 even on errors to prevent retries
32  }
33}