How to Integrate Bolt.new with Oberlo

Oberlo was shut down on June 15, 2022. Shopify gave users 30 days notice to migrate to alternative tools. After the shutdown date, all Oberlo API endpoints, webhook URLs, and the Oberlo app itself stopped functioning entirely. Any code in GitHub repositories, npm packages named 'oberlo-api', or tutorials describing Oberlo API integration were written before June 2022 and cannot be used to build a working integration. There is no Oberlo API endpoint to call and no Oberlo SDK to install. When you search for Oberlo integration code, you will find deprecated repositories that return 404 errors. The official Shopify migration guide directed users to DSers, which is an Oberlo-like tool built as a Shopify app with API access. If your intended use case is AliExpress dropshipping, DSers is the most direct replacement. If you want US and European suppliers with faster 2-5 day shipping, Spocket is the better choice. If you are building print-on-demand (custom-branded products), Printful is the standard choice and has the most comprehensive API. For this guide, the steps focus on Printful because it has the most developer-friendly API, clear documentation, and does not require being a Shopify merchant — you can build standalone dropshipping stores with Printful's API directly in Bolt without any Shopify dependency.

Printful is a print-on-demand dropshipping platform where you design custom products (apparel, home goods, accessories) and they manufacture, pack, and ship each order as it comes in. Printful's API lets you browse their product catalog, create product listings, submit orders for fulfillment, and track shipment status. Unlike Oberlo, Printful does not require a Shopify account — you can integrate directly via API. To get API access, create a free Printful account at printful.com. After signing up, navigate to Dashboard → Settings → Stores and create a new store (choose API platform if you are not connecting to Shopify, WooCommerce, or another specific platform). From your store settings, click Manage under API Access to generate an API key. The API key is a long alphanumeric string. Copy it immediately. Printful uses Bearer token authentication: include Authorization: Bearer YOUR_API_KEY in every API request header. The Printful API v2 base URL is https://api.printful.com. Authentication works for all endpoints: browsing the product catalog (/v2/catalog-products), managing your store's product listings, and submitting orders for fulfillment. During development in Bolt's WebContainer, all outbound calls to Printful's API work without any special configuration — product catalog calls return real data immediately. Create a .env entry for PRINTFUL_API_KEY and set up a lib/printful.ts helper.

1// lib/printful.ts
2export interface PrintfulProduct {
3  id: number;
4  name: string;
5  description: string;
6  thumbnail_url: string;
7  variants_count: number;
8  currency: string;
9}
10
11export interface PrintfulVariant {
12  id: number;
13  name: string;
14  price: string;
15  retail_price: string;
16  size: string;
17  color: string;
18  in_stock: boolean;
19}
20
21export async function callPrintful(path: string, options?: RequestInit) {
22  const response = await fetch(`https://api.printful.com${path}`, {
23    ...options,
24    headers: {
25      Authorization: `Bearer ${process.env.PRINTFUL_API_KEY}`,
26      'Content-Type': 'application/json',
27      ...options?.headers,
28    },
29  });
30
31  const data = await response.json();
32
33  if (!response.ok) {
34    throw new Error(
35      data?.error?.message || `Printful API error: ${response.status}`
36    );
37  }
38
39  return data;
40}

Printful's product catalog contains hundreds of blank products that can be customized with print-on-demand designs. Use the /v2/catalog-products endpoint to browse available products with filtering by category. Each catalog product has a unique ID, a name, a thumbnail, and a list of variants (size/color combinations). To import a product into your store, you create a sync product — a product in your Printful store account that links a catalog product with your design files and your retail pricing. For a Bolt-based dropshipping store that does not use Printful's design tools but wants to sell Printful products, the typical flow is: browse the catalog to find products, display them in your Bolt UI, let users add them to the store, and then use Printful's sync product API to register the import. Store the Printful product ID and variant details in your Supabase products table so your store UI can display them. When the customer places an order and provides their shipping address, you create a Printful order using the stored variant IDs. Building this flow in Bolt requires two API routes: one for fetching catalog products (GET) and one for creating sync products or storing the import in Supabase. The catalog fetch works in Bolt's WebContainer during development — it is a straightforward outbound GET request.

1// app/api/printful/catalog/route.ts
2import { NextResponse } from 'next/server';
3import { callPrintful } from '@/lib/printful';
4
5export async function GET() {
6  try {
7    const data = await callPrintful('/v2/catalog-products?limit=20&status=active');
8
9    const products = (data.result || data.data || []).map((product: Record<string, unknown>) => ({
10      id: product.id,
11      name: product.name,
12      thumbnail_url: product.thumbnail_url,
13      description: product.description || '',
14    }));
15
16    return NextResponse.json({ products });
17  } catch (error) {
18    const message = error instanceof Error ? error.message : 'Failed to fetch Printful catalog';
19    return NextResponse.json({ error: message }, { status: 500 });
20  }
21}

When a customer completes a purchase in your Bolt store, you need to submit an order to Printful for fulfillment. Printful will manufacture the product and ship it directly to the customer. The Printful order creation endpoint is POST /v2/orders. The order body requires: recipient (name, address, city, state_code, country_code, zip, email, phone), items (array of sync variant IDs or catalog variant IDs with quantity), and optionally retail_costs for pass-through pricing. Printful returns an order ID and estimated shipping cost. The order initially enters a draft state — you confirm it by calling POST /v2/orders/{id}/confirm, which triggers actual production. Consider adding a confirmation step in your workflow for order review before confirming. After confirmation, Printful processes the order and ships it. Tracking information becomes available via the Printful order status endpoint GET /v2/orders/{id}. For automatic tracking updates, Printful supports webhooks — POST shipping notifications to a URL you register in your Printful store settings. As with all incoming webhooks, the registered URL must be a deployed production URL — the WebContainer cannot receive these incoming POST requests from Printful's servers. Deploy to Netlify or Vercel first, then register the webhook URL in Printful's Dashboard → Settings → Webhooks.

1// app/api/printful/orders/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { callPrintful } from '@/lib/printful';
4import { createClient } from '@supabase/supabase-js';
5
6const supabase = createClient(
7  process.env.NEXT_PUBLIC_SUPABASE_URL!,
8  process.env.SUPABASE_SERVICE_ROLE_KEY!
9);
10
11export async function POST(request: NextRequest) {
12  const { variantId, quantity, recipient, boltOrderId, retailPrice } = await request.json();
13
14  try {
15    // Create Printful draft order
16    const order = await callPrintful('/v2/orders', {
17      method: 'POST',
18      body: JSON.stringify({
19        recipient,
20        items: [{ variant_id: variantId, quantity, retail_price: retailPrice?.toString() }],
21      }),
22    });
23
24    const printfulOrderId = order.result?.id || order.id;
25
26    // Confirm the order to start production
27    await callPrintful(`/v2/orders/${printfulOrderId}/confirm`, { method: 'POST' });
28
29    // Store in Supabase
30    await supabase.from('fulfillment_orders').insert({
31      bolt_order_id: boltOrderId,
32      printful_order_id: printfulOrderId,
33      status: 'confirmed',
34      supplier: 'printful',
35    });
36
37    return NextResponse.json({ printfulOrderId, status: 'confirmed' });
38  } catch (error) {
39    const message = error instanceof Error ? error.message : 'Order submission failed';
40    return NextResponse.json({ error: message }, { status: 500 });
41  }
42}

Your Bolt dropshipping app works in the WebContainer for all outbound operations — product catalog browsing, order submission, and status polling. The only feature that requires deployment is Printful's webhook notifications, which POST order status updates (order shipped, tracking number available) to your registered webhook URL. These incoming POST requests from Printful cannot reach the WebContainer. Deploy your Bolt app to Netlify or Vercel by connecting your GitHub repository. Set your environment variables in the hosting dashboard: PRINTFUL_API_KEY, NEXT_PUBLIC_SUPABASE_URL, NEXT_PUBLIC_SUPABASE_ANON_KEY, and SUPABASE_SERVICE_ROLE_KEY. After deployment, create a webhook handler at /api/printful/webhook that receives Printful order events. In your Printful Dashboard, navigate to Settings → Webhooks and add your deployed URL (https://your-app.netlify.app/api/printful/webhook). Select relevant events: order_updated, package_shipped, package_delivered. Printful includes an X-Printful-Signature header for webhook verification — validate it using HMAC-SHA256 with your webhook key. When a package ships, Printful sends the tracking number and carrier, which you can store in Supabase and email to the customer.

1// app/api/printful/webhook/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { createClient } from '@supabase/supabase-js';
4
5const supabase = createClient(
6  process.env.NEXT_PUBLIC_SUPABASE_URL!,
7  process.env.SUPABASE_SERVICE_ROLE_KEY!
8);
9
10export async function POST(request: NextRequest) {
11  const payload = await request.json();
12  const eventType = payload.type;
13  const orderData = payload.data?.order;
14
15  console.log(`Printful webhook: ${eventType}`, orderData?.id);
16
17  if (eventType === 'package_shipped' && orderData) {
18    const shipment = orderData.shipments?.[0];
19    await supabase
20      .from('fulfillment_orders')
21      .update({
22        status: 'shipped',
23        tracking_number: shipment?.tracking_number || '',
24        tracking_url: shipment?.tracking_url || '',
25        shipped_at: new Date().toISOString(),
26      })
27      .eq('printful_order_id', orderData.id);
28  } else if (eventType === 'order_updated' && orderData) {
29    await supabase
30      .from('fulfillment_orders')
31      .update({ status: orderData.status })
32      .eq('printful_order_id', orderData.id);
33  }
34
35  return NextResponse.json({ received: true });
36}