Bolt.new AI and Ecwid integration: Step-by-Step Guide 2025

To integrate Ecwid with a full‑stack app you build inside bolt.new, you don’t “connect bolt to Ecwid”. Instead, you write normal API calls from your backend code (Node/Express or similar) running inside the Bolt sandbox. Ecwid exposes a real REST API, and you authenticate using a Store ID + API token (or OAuth for public apps). So your app inside Bolt simply calls Ecwid endpoints like /api/v3/products, handles JSON responses, and stores the API token as an environment variable in Bolt. That’s the entire integration model.

 

What Ecwid Provides

 

Ecwid exposes a REST API where your backend can:

• Fetch products
• Create or update orders
• Manage inventory
• Read customers
• Listen to webhooks from Ecwid (e.g., new order created)

There are two authentication models:

• Private app / direct API token — simplest. You get a Store ID + API token from Ecwid admin.
• OAuth app — for public apps you want to publish.

Inside bolt.new, 99% of the time you start with the API token approach because it allows immediate testing.

 

What Bolt.new Provides

 

Bolt.new gives you a browser workspace where:

• You scaffold a Node backend (Express) and a frontend quickly.
• You store secrets in environment variables (process.env).
• You run the backend in a sandbox that can call external APIs.

There is no built‑in Ecwid connector. You integrate it exactly like a normal HTTP API.

 

Step‑by‑Step: The Simplest Working Integration

 

This shows you how to call Ecwid from a backend route inside a Bolt.new Node app.

You’ll need from Ecwid:

• storeId
• apiToken (read/write token)

Put them into Bolt environment variables:

• ECWID_STORE_ID
• ECWID_API_TOKEN

 

Create a backend route in Bolt that fetches products from Ecwid

 

// routes/ecwid.js
import express from "express";
import fetch from "node-fetch"; // bolt.new supports this import

const router = express.Router();

router.get("/products", async (req, res) => {
  try {
    const storeId = process.env.ECWID_STORE_ID;
    const token = process.env.ECWID_API_TOKEN;

    // Ecwid REST endpoint for fetching products
    const url = `https://app.ecwid.com/api/v3/${storeId}/products?token=${token}`;

    const response = await fetch(url); // real HTTP call
    const data = await response.json();

    res.json(data); // return Ecwid products to frontend
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

export default router;

 

Wire It into Your Express App

 

// server.js
import express from "express";
import ecwidRoutes from "./routes/ecwid.js";

const app = express();
app.use(express.json());

app.use("/api/ecwid", ecwidRoutes); // attaches the Ecwid routes

app.listen(3000, () => {
  console.log("Server running on port 3000");
});

 

Frontend Call Example (React inside Bolt)

 

// Fetch products from your own backend route in bolt.new

async function loadProducts() {
  const res = await fetch("/api/ecwid/products"); // calls your backend
  const data = await res.json();
  console.log(data); // shows Ecwid product list
}

 

Receiving Ecwid Webhooks in Bolt

 

If you want Ecwid to notify your Bolt app (e.g., a new order):

• Create a backend POST endpoint like /api/ecwid/webhook.
• Expose the Bolt dev server using something like ngrok (Bolt supports external exposes).
• Configure that URL in Ecwid admin → Webhooks.

// routes/ecwidWebhook.js
import express from "express";
const router = express.Router();

router.post("/webhook", (req, res) => {
  console.log("Ecwid webhook payload:", req.body); // handle event
  res.sendStatus(200); // must respond quickly
});

export default router;

 

Security Notes

 

• Never hardcode Ecwid tokens in code. Use Bolt environment variables.
• For production, rotate Ecwid API tokens regularly.
• Verify webhook signatures if your workflow requires integrity.

 

The Core Idea

 

Integrating Ecwid with Bolt.new is simply building a normal Node backend inside Bolt that calls Ecwid’s REST API using authenticated requests. Bolt doesn’t provide a special connector — you use real HTTP requests, store secrets in environment variables, and optionally set up webhooks for event-driven workflows. Everything is standard API integration, just scaffolded and tested quickly inside the Bolt environment.