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

There is no direct, built‑in Bolt.new → Signal integration, because Signal does not provide a traditional REST API for sending/receiving messages. But you can integrate Bolt.new apps with Signal by using an external Signal bridge that exposes a usable HTTP API (most commonly signal-cli-rest-api). Bolt.new then talks to that API the same way it talks to any external service: via HTTP fetch calls and environment variables for auth. So the actual connection is Bolt → your backend bridge → Signal network.

 

What You Actually Do

 

You set up a small Signal “bridge server” outside Bolt.new (because Bolt cannot run long‑lived binaries like signal-cli). That bridge provides an HTTP API. In Bolt.new, you call that API with fetch, using a token you configure as an environment variable. That’s the entire pattern.

• Bolt.new cannot run the official Signal app or Signal Desktop.
• Bolt.new cannot directly log in to Signal because Signal offers no public web API.
• Bolt.new can call any HTTP API you stand up outside Bolt.

 

The Standard Way: Use signal-cli + signal-cli-rest-api

 

This is the only reliable method today. signal-cli is an open-source command-line interface for Signal. The companion project signal-cli-rest-api wraps it with a REST server. That REST server runs on your own machine, a VPS, or a container platform.

The flow looks like this:

• You run signal-cli-rest-api somewhere stable (Docker is common).
• You register a Signal number there (QR code or SMS verification).
• You expose an HTTPS endpoint.
• Inside Bolt.new, you store the server URL + token in environment variables.
• Your Bolt app calls fetch(...) to send / receive messages.

 

How to Set Up the Signal Bridge (outside Bolt)

 

If you use Docker, the setup looks like this:

// Pull the REST API container
docker pull bbernhard/signal-cli-rest-api

// Run it locally (example dev config)
docker run -it -p 8080:8080 \
  -v signal-data:/home/.local/share/signal-cli \
  bbernhard/signal-cli-rest-api

 

You then open the local web UI at:

• http://localhost:8080

Use it to register your Signal number. After registration, you will have HTTP endpoints such as:

• POST /v1/messages
• GET /v1/receive

You can optionally add an API token using a simple reverse proxy (Traefik, Caddy, NGINX) or by placing the service behind a private network.

 

Integrating with Bolt.new

 

Inside Bolt.new, you store your API URL and token in environment variables (because Bolt apps must not hardcode secrets). In the editor, you typically create:

• SIGNAL_API_URL
• SIGNAL_API_TOKEN

Then you call the Signal REST API using regular fetch:

// Example: send a Signal message from a Bolt.new server route

export default async function handler(req, res) {
  try {
    const apiUrl = process.env.SIGNAL_API_URL      // https://your-signal-bridge.example.com
    const token = process.env.SIGNAL_API_TOKEN     // your auth token if using reverse proxy

    const result = await fetch(apiUrl + "/v1/messages", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${token}`        // only if you configured auth
      },
      body: JSON.stringify({
        message: "Hello from Bolt.new!",
        number: "+1234567890",                   // your registered Signal number
        recipients: ["+10987654321"]             // recipient numbers
      })
    })

    const data = await result.json()

    res.status(200).json({ ok: true, response: data })
  } catch (err) {
    res.status(500).json({ ok: false, error: err.toString() })
  }
}

 

Receiving Messages (Webhook Pattern)

 

Signal itself does not push webhooks. The REST wrapper provides a polling endpoint called /v1/receive.

In Bolt.new, you typically create a small scheduled poller (using a serverless cron outside Bolt or your own script) that hits your Bolt API route. Your Bolt route then fetches unread messages:

// Example: poll for incoming Signal messages

export default async function handler(req, res) {
  const apiUrl = process.env.SIGNAL_API_URL
  const token = process.env.SIGNAL_API_TOKEN

  const r = await fetch(apiUrl + "/v1/receive/+1234567890", {   // your Signal number
    headers: {
      "Authorization": `Bearer ${token}`
    }
  })

  const messages = await r.json()

  // Process them however you need
  console.log("Incoming Signal:", messages)

  res.status(200).json({ messages })
}

 

Important Constraints

 

• Signal does not provide an official public API for bots or servers.
• You must run the bridge yourself (Docker, VPS, or home machine).
• Bolt cannot host the Signal client; it can only call your HTTP endpoint.
• Use HTTPS and a secret header when exposing the bridge publicly.
• Registration requires SMS or QR code verification once.

 

Summary

 

Integrating Bolt.new with Signal is absolutely possible, but it requires running your own Signal bridge server using signal-cli + signal-cli-rest-api. Bolt.new itself only sends requests; all Signal protocol work happens in the external service. Once the bridge is running, Bolt.new simply calls it with fetch, like any other API.