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

To integrate Bolt.new AI with Miro, you do not “connect Bolt to Miro directly.” Instead, you build a small backend inside Bolt (Node, Next.js, or any starter) that talks to the real Miro REST API using OAuth or a Miro personal access token. Bolt.new simply hosts the code you write during development. The integration itself is just normal API calls from your Bolt backend to Miro’s API.

The simplest working setup inside Bolt is: you create a Miro OAuth app, store its credentials in Bolt environment variables, implement the OAuth callback route, then make authenticated REST requests to create or read boards/items. Bolt doesn’t add any proprietary layer — it’s just a fast workspace where you scaffold the integration like any other backend API integration.

 

What integration really means

 

Miro exposes a public REST API. Bolt.new gives you a runtime (Node.js in the server folder) where you can call that API. So “integration” = you write code in Bolt that sends HTTP requests to Miro using fetch() or a library like axios. Authentication uses:

• OAuth 2.0 (recommended for user-facing workflows)
• Personal Access Token (simplest for prototypes, but tied to your account)

Below is the exact sequence that works in reality — nothing proprietary, nothing hidden.

 

Steps to integrate Bolt.new with Miro

 

• Create a Miro Developer App: Go to https://developers.miro.com → “My Apps”. Create an app and set its OAuth redirect URL to something like http://localhost:3000/api/miro/callback (Bolt.new dev server).
• Copy your Client ID and Client Secret: These are needed for OAuth. Put them into Bolt environment variables (in the Env panel):
  MIRO_CLIENT_ID=...
MIRO_CLIENT_SECRET=...
• Add an OAuth route to your Bolt backend: This is a simple redirect to Miro’s auth page.
• Implement the OAuth callback route: Exchange the authorization code for an access token.
• Use the token to call the Miro API: Use fetch() to hit endpoints like https://api.miro.com/v2/boards.

 

Minimal working OAuth integration in Bolt.new

 

Inside Bolt, create a backend route like /api/miro/login that starts the login flow:

// server/api/miro/login.js

export default async function handler(req, res) {
  const clientId = process.env.MIRO_CLIENT_ID
  const redirectUri = "http://localhost:3000/api/miro/callback"

  const url =
    "https://miro.com/oauth/authorize?" +
    new URLSearchParams({
      response_type: "code",
      client_id: clientId,
      redirect_uri: redirectUri
    })

  res.redirect(url)
}

 

Then add the OAuth callback route:

// server/api/miro/callback.js

export default async function handler(req, res) {
  const code = req.query.code
  const redirectUri = "http://localhost:3000/api/miro/callback"

  const tokenRes = await fetch("https://api.miro.com/v1/oauth/token", {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
      grant_type: "authorization_code",
      code,
      redirect_uri: redirectUri,
      client_id: process.env.MIRO_CLIENT_ID,
      client_secret: process.env.MIRO_CLIENT_SECRET
    })
  })

  const tokenData = await tokenRes.json()

  // Store tokenData.access_token somewhere secure.
  // In Bolt prototype you can store it in memory or pass to client.

  res.json(tokenData)
}

 

A simple authenticated call to list boards:

// server/api/miro/boards.js

export default async function handler(req, res) {
  const accessToken = req.headers["x-miro-token"] // from client or session

  const r = await fetch("https://api.miro.com/v2/boards", {
    headers: {
      Authorization: "Bearer " + accessToken
    }
  })

  const data = await r.json()
  res.json(data)
}

 

Running this in Bolt.new

 

• Start Bolt’s dev server.
• Go to /api/miro/login → Miro login.
• After approval, the callback returns the token.
• You can now call your own /api/miro/boards route to fetch boards.

 

Deploying outside Bolt (hardening)

 

• Store tokens in a database or session (not in memory).
• Use HTTPS redirect URIs.
• Never expose the client secret to the frontend.
• Implement refresh tokens (Miro provides them in OAuth response).

 

This is the only real and valid way to integrate Bolt.new with Miro: build a normal Node backend inside Bolt and call Miro’s official REST API using OAuth or a personal token. No hidden features or special Bolt plugins — just standard web integration patterns.