How to Integrate Bolt.new with Printful

1// src/lib/printful.ts
2const PRINTFUL_BASE = 'https://api.printful.com';
3
4interface PrintfulResponse<T> {
5  code: number;
6  result: T;
7  error?: string;
8}
9
10export async function printfulFetch<T>(
11  path: string,
12  options: RequestInit = {}
13): Promise<T> {
14  const apiKey = process.env.PRINTFUL_API_KEY;
15  if (!apiKey) throw new Error('PRINTFUL_API_KEY is not set');
16
17  const response = await fetch(`${PRINTFUL_BASE}/${path}`, {
18    ...options,
19    headers: {
20      Authorization: `Bearer ${apiKey}`,
21      'Content-Type': 'application/json',
22      ...options.headers,
23    },
24  });
25
26  const data: PrintfulResponse<T> = await response.json();
27
28  if (data.code !== 200) {
29    throw new Error(`Printful API error ${data.code}: ${data.error ?? 'Unknown error'}`);
30  }
31
32  return data.result;
33}

1// app/api/printful/products/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { printfulFetch } from '@/lib/printful';
4
5interface PrintfulVariant {
6  id: number;
7  price: string;
8  in_stock: boolean;
9}
10
11interface PrintfulProduct {
12  id: number;
13  title: string;
14  image: string;
15  description: string;
16  variants: PrintfulVariant[];
17}
18
19export async function GET(request: NextRequest) {
20  try {
21    const limit = request.nextUrl.searchParams.get('limit') ?? '20';
22    const categoryId = request.nextUrl.searchParams.get('category_id') ?? '';
23
24    const queryParts = [`limit=${limit}`, 'offset=0'];
25    if (categoryId) queryParts.push(`category_id=${categoryId}`);
26
27    const products = await printfulFetch<PrintfulProduct[]>(
28      `products?${queryParts.join('&')}`
29    );
30
31    const cleaned = products.map(p => ({
32      id: p.id,
33      title: p.title,
34      image: p.image,
35      description: p.description,
36      startingPrice: p.variants.length
37        ? Math.min(...p.variants.map(v => parseFloat(v.price))).toFixed(2)
38        : null,
39      variantCount: p.variants.length,
40    }));
41
42    return NextResponse.json({ products: cleaned });
43  } catch (err: any) {
44    return NextResponse.json({ error: err.message }, { status: 500 });
45  }
46}

1// app/api/printful/mockup/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { printfulFetch } from '@/lib/printful';
4
5interface MockupTask {
6  task_key: string;
7  status: string;
8  mockups?: Array<{
9    placement: string;
10    mockup_url: string;
11    extra: Array<{ title: string; url: string }>;
12  }>;
13}
14
15export async function POST(request: NextRequest) {
16  const { productId, variantIds, imageUrl } = await request.json();
17
18  try {
19    // Step 1: Create mockup generation task
20    const task = await printfulFetch<MockupTask>(
21      `mockup-generator/create-task/${productId}`,
22      {
23        method: 'POST',
24        body: JSON.stringify({
25          variant_ids: variantIds,
26          files: [{ placement: 'front', image_url: imageUrl, position: { area_width: 1800, area_height: 2400, width: 1800, height: 1800, top: 300, left: 0 } }],
27          format: 'jpg',
28          width: 1000,
29        }),
30      }
31    );
32
33    const taskKey = task.task_key;
34
35    // Step 2: Poll for result (up to 60 seconds)
36    for (let attempt = 0; attempt < 20; attempt++) {
37      await new Promise(resolve => setTimeout(resolve, 3000)); // wait 3s
38
39      const result = await printfulFetch<MockupTask>(
40        `mockup-generator/task?task_key=${taskKey}`
41      );
42
43      if (result.status === 'completed') {
44        const mockupUrls = result.mockups?.map(m => ({
45          placement: m.placement,
46          url: m.mockup_url,
47        })) ?? [];
48        return NextResponse.json({ mockups: mockupUrls });
49      }
50
51      if (result.status === 'failed') {
52        return NextResponse.json({ error: 'Mockup generation failed' }, { status: 500 });
53      }
54    }
55
56    return NextResponse.json({ error: 'Mockup generation timed out' }, { status: 408 });
57  } catch (err: any) {
58    return NextResponse.json({ error: err.message }, { status: 500 });
59  }
60}

1// app/api/printful/orders/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { printfulFetch } from '@/lib/printful';
4
5interface PrintfulOrder {
6  id: number;
7  external_id: string;
8  status: string;
9  shipping: string;
10  created: number;
11}
12
13export async function POST(request: NextRequest) {
14  const { recipient, items, externalId } = await request.json();
15
16  // Validate required fields
17  if (!recipient?.address1 || !recipient?.city || !recipient?.country_code) {
18    return NextResponse.json({ error: 'Complete shipping address required' }, { status: 400 });
19  }
20
21  try {
22    const order = await printfulFetch<PrintfulOrder>('orders', {
23      method: 'POST',
24      body: JSON.stringify({
25        external_id: externalId ?? `order_${Date.now()}`,
26        shipping: 'STANDARD', // Standard shipping
27        recipient: {
28          name: recipient.name,
29          address1: recipient.address1,
30          address2: recipient.address2 ?? '',
31          city: recipient.city,
32          state_code: recipient.state_code ?? '',
33          country_code: recipient.country_code,
34          zip: recipient.zip,
35          email: recipient.email,
36        },
37        items: items.map((item: any) => ({
38          sync_variant_id: item.syncVariantId,
39          quantity: item.quantity ?? 1,
40          retail_price: item.retailPrice, // The price you charged the customer
41        })),
42        // Use confirm: false during development — creates a draft order without processing
43        confirm: process.env.NODE_ENV === 'production',
44      }),
45    });
46
47    return NextResponse.json({
48      orderId: order.id,
49      externalId: order.external_id,
50      status: order.status,
51    }, { status: 201 });
52  } catch (err: any) {
53    return NextResponse.json({ error: err.message }, { status: 500 });
54  }
55}