How to Integrate Bolt.new with UPS API

1# .env — add to project root
2UPS_CLIENT_ID=your_ups_client_id_here
3UPS_CLIENT_SECRET=your_ups_client_secret_here
4UPS_ACCOUNT_NUMBER=your_ups_account_number_here
5# Use CIE for testing, onlinetools.ups.com for production
6UPS_BASE_URL=https://wwwcie.ups.com

1// lib/ups-auth.ts
2interface UpsTokenResponse {
3  token_type: string;
4  issued_at: string;
5  client_id: string;
6  access_token: string;
7  expires_in: string;
8  status: string;
9}
10
11export async function getUpsToken(): Promise<string> {
12  const clientId = process.env.UPS_CLIENT_ID;
13  const clientSecret = process.env.UPS_CLIENT_SECRET;
14  const baseUrl = process.env.UPS_BASE_URL || 'https://wwwcie.ups.com';
15
16  if (!clientId || !clientSecret) {
17    throw new Error('UPS_CLIENT_ID and UPS_CLIENT_SECRET must be configured');
18  }
19
20  // UPS OAuth requires Basic auth with Base64-encoded credentials
21  const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
22
23  const response = await fetch(`${baseUrl}/security/v1/oauth/token`, {
24    method: 'POST',
25    headers: {
26      'Authorization': `Basic ${credentials}`,
27      'Content-Type': 'application/x-www-form-urlencoded',
28      'x-merchant-id': process.env.UPS_ACCOUNT_NUMBER || '',
29    },
30    body: 'grant_type=client_credentials',
31  });
32
33  if (!response.ok) {
34    const error = await response.text();
35    throw new Error(`UPS OAuth error ${response.status}: ${error}`);
36  }
37
38  const data: UpsTokenResponse = await response.json();
39  return data.access_token;
40}

1// app/api/ups/track/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { getUpsToken } from '@/lib/ups-auth';
4
5interface UpsActivity {
6  location?: { address?: { city?: string; stateProvince?: string; countryCode?: string } };
7  status?: { description?: string; type?: string };
8  date?: string;
9  time?: string;
10}
11
12export async function GET(request: NextRequest) {
13  const trackingNumber = new URL(request.url).searchParams.get('trackingNumber');
14  if (!trackingNumber) {
15    return NextResponse.json({ error: 'trackingNumber is required' }, { status: 400 });
16  }
17
18  const baseUrl = process.env.UPS_BASE_URL || 'https://wwwcie.ups.com';
19
20  try {
21    const token = await getUpsToken();
22
23    const response = await fetch(
24      `${baseUrl}/api/track/v1/details/${encodeURIComponent(trackingNumber)}`,
25      {
26        headers: {
27          Authorization: `Bearer ${token}`,
28          transId: crypto.randomUUID(),
29          transactionSrc: 'BoltShippingApp',
30          'Content-Type': 'application/json',
31        },
32      }
33    );
34
35    if (!response.ok) {
36      const error = await response.json();
37      return NextResponse.json(
38        { error: error.response?.errors?.[0]?.message || 'UPS API error' },
39        { status: response.status }
40      );
41    }
42
43    const data = await response.json();
44    const shipment = data.trackResponse?.shipment?.[0];
45
46    if (!shipment) {
47      return NextResponse.json({ error: 'Tracking number not found' }, { status: 404 });
48    }
49
50    const package_ = shipment.package?.[0];
51    const activities: UpsActivity[] = package_?.activity || [];
52
53    return NextResponse.json({
54      trackingNumber,
55      status: package_?.currentStatus?.description || 'Unknown',
56      estimatedDelivery: package_?.deliveryDate?.[0]?.date || null,
57      origin: {
58        city: shipment.shipper?.address?.city,
59        state: shipment.shipper?.address?.stateProvince,
60      },
61      destination: {
62        city: shipment.shipTo?.address?.city,
63        state: shipment.shipTo?.address?.stateProvince,
64      },
65      activities: activities.map((a) => ({
66        date: a.date,
67        time: a.time,
68        description: a.status?.description,
69        location: [
70          a.location?.address?.city,
71          a.location?.address?.stateProvince,
72          a.location?.address?.countryCode,
73        ]
74          .filter(Boolean)
75          .join(', '),
76      })),
77    });
78  } catch (error) {
79    const message = error instanceof Error ? error.message : 'Unknown error';
80    return NextResponse.json({ error: message }, { status: 500 });
81  }
82}

1// app/api/ups/rates/route.ts
2import { NextResponse } from 'next/server';
3import { getUpsToken } from '@/lib/ups-auth';
4
5export async function POST(request: Request) {
6  const { shipperPostalCode, recipientPostalCode, recipientCountryCode, weightLbs } =
7    await request.json();
8
9  const baseUrl = process.env.UPS_BASE_URL || 'https://wwwcie.ups.com';
10  const accountNumber = process.env.UPS_ACCOUNT_NUMBER;
11
12  try {
13    const token = await getUpsToken();
14
15    const ratePayload = {
16      RateRequest: {
17        Request: { SubVersion: '1703', TransactionReference: { CustomerContext: 'RateRequest' } },
18        Shipment: {
19          Shipper: {
20            ShipperNumber: accountNumber,
21            Address: { PostalCode: shipperPostalCode, CountryCode: 'US' },
22          },
23          ShipTo: {
24            Address: {
25              PostalCode: recipientPostalCode,
26              CountryCode: recipientCountryCode || 'US',
27              ResidentialAddressIndicator: '',
28            },
29          },
30          ShipFrom: {
31            Address: { PostalCode: shipperPostalCode, CountryCode: 'US' },
32          },
33          Package: {
34            PackagingType: { Code: '02', Description: 'Package' },
35            PackageWeight: {
36              UnitOfMeasurement: { Code: 'LBS' },
37              Weight: String(weightLbs || 1),
38            },
39          },
40        },
41      },
42    };
43
44    const response = await fetch(`${baseUrl}/api/rating/v1/Shop`, {
45      method: 'POST',
46      headers: {
47        Authorization: `Bearer ${token}`,
48        transId: crypto.randomUUID(),
49        transactionSrc: 'BoltShippingApp',
50        'Content-Type': 'application/json',
51      },
52      body: JSON.stringify(ratePayload),
53    });
54
55    const data = await response.json();
56    const ratedShipments = data.RateResponse?.RatedShipment || [];
57
58    const rates = ratedShipments.map((s: Record<string, { Code?: string; MonetaryValue?: string; BusinessDaysInTransit?: string }>) => ({
59      serviceCode: s.Service?.Code,
60      price: parseFloat(s.TotalCharges?.MonetaryValue || '0'),
61      currency: 'USD',
62      daysInTransit: s.GuaranteedDelivery?.BusinessDaysInTransit || null,
63    }));
64
65    rates.sort((a: { price: number }, b: { price: number }) => a.price - b.price);
66    return NextResponse.json({ rates });
67  } catch (error) {
68    const message = error instanceof Error ? error.message : 'Unknown error';
69    return NextResponse.json({ error: message }, { status: 500 });
70  }
71}