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

The direct answer is: there is no native or automatic “Bolt.new → Mural integration.” To integrate them, you treat Mural as a normal external API. That means you build an app inside Bolt.new that authenticates with Mural using OAuth2 or a Personal Access Token, then you call Mural’s REST API endpoints (such as creating murals, fetching widgets, or adding content). All integration happens through standard HTTP requests that you write inside your Bolt.new backend code. Nothing is “magic”; you wire it manually using real API calls.

 

What Mural Actually Provides

 

Mural exposes a real REST API. This is the only reliable way to integrate Bolt.new with Mural. Mural supports:

• OAuth2 authentication (user-based authorization)
• Personal Access Tokens (service-account style)
• Standard REST endpoints for murals, workspaces, members, widgets, etc.

In Bolt.new, you can use either approach, but Personal Access Tokens are easier when prototyping because you avoid OAuth redirects.

 

The Integration Pattern (the REAL one)

 

You build a tiny backend in Bolt.new that does this:

• Store the Mural token in an environment variable (never hardcode).
• Expose routes (e.g., /create-mural, /list-murals) that your front-end can call.
• Use fetch or axios inside the backend to call Mural’s REST API.

You are effectively acting as your own API bridge: Bolt.new → your backend → Mural’s API.

 

Minimal Example (really works, really hits Mural API)

 

This example shows a Bolt.new backend route that fetches the user’s murals from Mural's API.

// routes/murals.js
import express from "express";
import fetch from "node-fetch";

const router = express.Router();

router.get("/list", async (req, res) => {
  try {
    const response = await fetch("https://api.mural.co/api/public/v1/murals", {
      method: "GET",
      headers: {
        "Authorization": `Bearer ${process.env.MURAL_TOKEN}`, // Store token in Bolt env vars
        "Content-Type": "application/json"
      }
    });

    const data = await response.json();
    res.json(data); // Send Mural API response to frontend
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: "Error calling Mural API" });
  }
});

export default router;

This is the standard pattern: authenticate, call, return.

 

How to Set Environment Variables in Bolt.new

 

In the Bolt.new workspace:

• Open the Environment panel
• Add something like MURAL_TOKEN=your_mural_personal_access\_token
• Restart the preview server

Your backend can now read it via process.env.MURAL\_TOKEN.

 

How OAuth2 Works If You Want Full Production Setup

 

If you want to allow other users to connect their Mural accounts, you must implement OAuth2:

• You register your app in Mural’s developer console.
• Mural gives you a client ID and client secret.
• You create a route (e.g., /oauth/callback) inside Bolt.new.
• User logs into Mural → Mural redirects back to your callback route with a code.
• Your backend exchanges that code for an access token.

This is exactly how Google, Slack, or GitHub OAuth works.

 

Common Real-World Use Cases

 

• Generate murals programmatically — create a new board for every client workshop.
• Add sticky notes automatically — e.g., Bolt AI generates brainstorm items and posts them to Mural.
• Sync external data — e.g., send product backlog items from Jira into a Mural canvas.

All of this uses the same pattern: authenticate → call Mural REST API → render/update UI.

 

How You Prototype in Bolt.new vs. Production

 

In Bolt.new:

• Use Personal Access Token for fastest testing.
• Use a single backend route.
• Hard-code minimal parameters while testing.

Outside Bolt.new (real app):

• Use OAuth2 for multi-user access.
• Move secrets into secure secret managers (AWS, GCP, etc.).
• Implement proper error handling and token refresh.

Bolt is your sandbox; production is where you scale and secure it.

 

Summary

 

Integrating Bolt.new with Mural means building a normal REST API integration. Bolt does not natively "connect" to Mural; you implement the API calls yourself. Use environment variables, write backend routes, and call Mural’s REST API through those routes. For quick prototypes, use a Personal Access Token; for real apps, use OAuth2. Everything is done through standard HTTP requests you write explicitly.