Bolt.new AI and Let's Encrypt integration: Step-by-Step Guide 2025

There is no direct or special “Bolt.new ↔ Let’s Encrypt integration”. What you actually do is: you use Bolt.new to build the backend code (Node, Python, etc.) that performs a standard Let’s Encrypt ACME HTTP‑01 challenge, then you deploy that backend to a real hosting environment that can expose port 80/443 to the public. Bolt.new itself cannot receive the ACME challenge because its dev server is not a publicly-routable domain, so Let’s Encrypt cannot validate it. In other words: Bolt.new helps you write and test the code, but certificate issuance must happen on your actual server.

If you need this in one sentence: you integrate Bolt.new with Let’s Encrypt by writing normal ACME automation code in Bolt, then running that code on a real server that exposes /.well-known/acme-challenge/\* so Let’s Encrypt can validate your domain.

 

How this works in reality

 

Let’s Encrypt issues SSL/TLS certificates using the ACME protocol. ACME requires your server (not Bolt) to prove domain ownership, usually by answering an HTTP‑01 challenge. Bolt.new is only your coding workspace; it does not provide a stable public domain for ACME validation. So your integration steps are:

• Use Bolt.new to scaffold your server’s ACME code (e.g., using acme-client in Node.js).
• Move that code to your actual hosting environment (VPS, Docker host, Vercel server, etc.).
• Expose /.well-known/acme-challenge on port 80 of a real publicly reachable domain.
• Run the ACME client code to request and renew certificates.
• Store your certs in your hosting environment (not inside Bolt).

This is exactly the same pattern as integrating with any external system: Bolt.new writes and tests logic, but the real HTTPS certificate lifecycle occurs on your server.

 

Minimal Node.js ACME (Let’s Encrypt) Example You Can Scaffold in Bolt.new

 

This example uses the real acme-client library. This is production-valid and follows ACME HTTP‑01 rules. You cannot complete the challenge inside Bolt; you must deploy it to your real domain.

 

// install in your bolt.new workspace:
// npm install acme-client express

import express from 'express'
import * as acme from 'acme-client'
import fs from 'fs'

const app = express()

// Map to temporarily store challenge tokens
const challenges = new Map()

// Required endpoint for HTTP-01 challenge
app.get('/.well-known/acme-challenge/:token', (req, res) => {
  const keyAuth = challenges.get(req.params.token)
  if (!keyAuth) {
    res.status(404).send('Not found')
    return
  }
  res.type('text/plain').send(keyAuth)
})

async function getCertificate() {
  const client = new acme.Client({
    directoryUrl: acme.DirectoryUrl.letsencrypt.production,
    accountKey: await acme.forge.createPrivateKey()
  })

  const domain = 'your-real-domain.com' // replace with your public domain

  // Create domain private key
  const domainPrivKey = await acme.forge.createPrivateKey()

  // Create certificate order
  const order = await client.createOrder({
    identifiers: [{ type: 'dns', value: domain }]
  })

  // Get challenge for HTTP-01
  const authorizations = await client.getAuthorizations(order)
  const httpChallenge = authorizations[0].challenges.find(c => c.type === 'http-01')

  // Generate key authorization
  const keyAuthorization = await client.getChallengeKeyAuthorization(httpChallenge)

  // Store the token mapping for Let’s Encrypt validation
  challenges.set(httpChallenge.token, keyAuthorization)

  // Tell Let's Encrypt the challenge is ready
  await client.verifyChallenge(authorizations[0], httpChallenge)
  await client.completeChallenge(httpChallenge)

  // Wait until the challenge is valid
  await client.waitForValidStatus(httpChallenge)

  // Finalize and download certificate
  const csr = await acme.forge.createCsr({ commonName: domain }, domainPrivKey)
  const cert = await client.getCertificate(await client.finalizeOrder(order, csr))

  fs.writeFileSync('privkey.pem', domainPrivKey)
  fs.writeFileSync('cert.pem', cert)
  console.log('Certificate ready!')
}

app.listen(80, () => {
  console.log('Server running on port 80 for ACME challenge')
  // getCertificate() must run after deploying to a public server
})

 

What this means for Bolt.new

 

Bolt.new is used for the development stage only:

• You write code like the snippet above.
• You test local flow (except the real ACME validation, which cannot run inside bolt).
• You deploy the generated code to a server with a public IP or reverse proxy.
• Let’s Encrypt validates your domain against that deployed server.

This is the correct and real-world-valid way to “integrate Bolt.new with Let’s Encrypt”. The integration is just standard ACME code that Bolt helps you build, not a direct bolt feature.