How to Integrate Bolt.new with FedEx API

1// lib/fedex.ts
2interface TokenCache {
3  token: string;
4  expiresAt: number;
5}
6
7let tokenCache: TokenCache | null = null;
8
9async function getFedExToken(): Promise<string> {
10  const now = Date.now();
11  // Return cached token if still valid (with 60s buffer)
12  if (tokenCache && tokenCache.expiresAt > now + 60_000) {
13    return tokenCache.token;
14  }
15
16  const clientId = process.env.FEDEX_CLIENT_ID;
17  const clientSecret = process.env.FEDEX_CLIENT_SECRET;
18  const baseUrl = process.env.FEDEX_API_BASE_URL ?? 'https://apis-sandbox.fedex.com';
19
20  if (!clientId || !clientSecret) {
21    throw new Error('FEDEX_CLIENT_ID and FEDEX_CLIENT_SECRET must be set in .env');
22  }
23
24  const response = await fetch(`${baseUrl}/oauth/token`, {
25    method: 'POST',
26    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
27    body: new URLSearchParams({
28      grant_type: 'client_credentials',
29      client_id: clientId,
30      client_secret: clientSecret,
31    }),
32  });
33
34  if (!response.ok) {
35    const err = await response.text();
36    throw new Error(`FedEx token exchange failed: ${err}`);
37  }
38
39  const data = await response.json() as { access_token: string; expires_in: number };
40  tokenCache = {
41    token: data.access_token,
42    expiresAt: now + data.expires_in * 1000,
43  };
44
45  return data.access_token;
46}
47
48export async function fedexFetch<T = unknown>(
49  endpoint: string,
50  init: RequestInit = {}
51): Promise<T> {
52  const token = await getFedExToken();
53  const baseUrl = process.env.FEDEX_API_BASE_URL ?? 'https://apis-sandbox.fedex.com';
54  const url = `${baseUrl}${endpoint.startsWith('/') ? endpoint : '/' + endpoint}`;
55
56  const response = await fetch(url, {
57    ...init,
58    headers: {
59      Authorization: `Bearer ${token}`,
60      'Content-Type': 'application/json',
61      'X-Customer-Transaction-Id': `bolt-${Date.now()}`,
62      'X-locale': 'en_US',
63      ...init.headers,
64    },
65  });
66
67  if (!response.ok) {
68    const errorData = await response.text();
69    throw new Error(`FedEx API ${response.status} at ${endpoint}: ${errorData}`);
70  }
71
72  return response.json() as Promise<T>;
73}

1// app/api/fedex/track/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { fedexFetch } from '@/lib/fedex';
4
5export async function POST(request: NextRequest) {
6  const { trackingNumber } = await request.json();
7
8  if (!trackingNumber?.trim()) {
9    return NextResponse.json({ error: 'trackingNumber is required' }, { status: 400 });
10  }
11
12  const body = {
13    includeDetailedScans: true,
14    trackingInfo: [{
15      trackingNumberInfo: { trackingNumber: trackingNumber.trim() },
16    }],
17  };
18
19  const data = await fedexFetch<Record<string, unknown>>('/track/v1/trackingnumbers', {
20    method: 'POST',
21    body: JSON.stringify(body),
22  });
23
24  const trackResult = (
25    data as {
26      output?: {
27        completeTrackResults?: Array<{
28          trackResults?: Array<{
29            latestStatusDetail?: { description: string; code: string };
30            estimatedDeliveryTimeWindow?: { window?: { ends?: string } };
31            scanEvents?: Array<{
32              date: string;
33              time: string;
34              eventType: string;
35              eventDescription: string;
36              scanLocation?: { city: string; stateOrProvinceCode: string };
37            }>;
38          }>;
39        }>;
40      };
41    }
42  )?.output?.completeTrackResults?.[0]?.trackResults?.[0];
43
44  if (!trackResult) {
45    return NextResponse.json({ error: 'Tracking number not found' }, { status: 404 });
46  }
47
48  const events = (trackResult.scanEvents ?? []).slice(0, 5).map(e => ({
49    date: e.date,
50    time: e.time,
51    description: e.eventDescription,
52    location: e.scanLocation
53      ? `${e.scanLocation.city}, ${e.scanLocation.stateOrProvinceCode}`
54      : 'Unknown location',
55  }));
56
57  return NextResponse.json({
58    status: trackResult.latestStatusDetail?.code,
59    description: trackResult.latestStatusDetail?.description,
60    estimatedDelivery: trackResult.estimatedDeliveryTimeWindow?.window?.ends,
61    events,
62  });
63}

1// app/api/fedex/rates/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { fedexFetch } from '@/lib/fedex';
4
5export async function POST(request: NextRequest) {
6  const { fromZip, toZip, weightLbs, toResidential = false, dimensions } =
7    await request.json();
8
9  if (!fromZip || !toZip || !weightLbs) {
10    return NextResponse.json(
11      { error: 'fromZip, toZip, and weightLbs are required' },
12      { status: 400 }
13    );
14  }
15
16  const requestBody = {
17    accountNumber: { value: process.env.FEDEX_ACCOUNT_NUMBER ?? '' },
18    rateRequestType: ['LIST'],
19    requestedShipment: {
20      shipper: {
21        address: {
22          postalCode: fromZip,
23          countryCode: 'US',
24          residential: false,
25        },
26      },
27      recipient: {
28        address: {
29          postalCode: toZip,
30          countryCode: 'US',
31          residential: toResidential,
32        },
33      },
34      pickupType: 'USE_SCHEDULED_PICKUP',
35      rateRequestType: ['LIST'],
36      requestedPackageLineItems: [{
37        weight: { value: weightLbs, units: 'LB' },
38        ...(dimensions ? {
39          dimensions: {
40            length: dimensions.length,
41            width: dimensions.width,
42            height: dimensions.height,
43            units: 'IN',
44          },
45        } : {}),
46      }],
47    },
48  };
49
50  const data = await fedexFetch<Record<string, unknown>>('/rate/v1/rates/quotes', {
51    method: 'POST',
52    body: JSON.stringify(requestBody),
53  });
54
55  const details = (data as { output?: { rateReplyDetails?: unknown[] } })
56    ?.output?.rateReplyDetails ?? [];
57
58  const rates = (details as Array<Record<string, unknown>>).map(d => {
59    const ratedDetails = (d.ratedShipmentDetails as Array<Record<string, unknown>>)?.[0];
60    const charges = ratedDetails?.shipmentRateDetail as Record<string, unknown>;
61    const totalCharge = (charges?.totalNetCharge as Record<string, unknown>);
62    return {
63      serviceType: d.serviceType,
64      serviceName: d.serviceName,
65      deliveryDate: (d.commit as Record<string, unknown>)?.dateDetail,
66      totalCharge: Number(totalCharge?.amount ?? 0),
67      currency: String(totalCharge?.currency ?? 'USD'),
68    };
69  }).sort((a, b) => a.totalCharge - b.totalCharge);
70
71  return NextResponse.json({ rates });
72}

1// netlify.toml
2[[plugins]]
3package = "@netlify/plugin-nextjs"
4
5[build]
6  command = "npm run build"
7  publish = ".next"
8
9[build.environment]
10  NEXT_TELEMETRY_DISABLED = "1"
11
12# Environment variables needed (set in Netlify dashboard):
13# FEDEX_CLIENT_ID — from FedEx Developer Portal (production project)
14# FEDEX_CLIENT_SECRET — from FedEx Developer Portal (production project)
15# FEDEX_API_BASE_URL — https://apis.fedex.com (production) or https://apis-sandbox.fedex.com (sandbox)
16# FEDEX_ACCOUNT_NUMBER — your FedEx account number (required for rating API)