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

The direct, practical answer: You don’t “integrate Bolt.new with LearnWorlds” as a built‑in feature. Instead, you integrate your Bolt.new app with LearnWorlds using LearnWorlds’ real APIs (REST), plus webhook endpoints you host inside your Bolt.new project. The integration is the same as with any external system: you call LearnWorlds’ API via HTTPS with an API key, parse the JSON response, and expose your own endpoints for LearnWorlds to call back when events happen.

Bolt.new itself is just your workspace. The integration happens in the code you write inside it.

 

What LearnWorlds Actually Provides

 

LearnWorlds exposes a real REST API. This is how you connect your Bolt.new project to it. Everything else (automations, SSO, course enrollment, user creation) happens through these endpoints.

The key LearnWorlds features you can use in Bolt:

• REST API with API keys
• Endpoints for users, courses, enrollments, purchases
• Webhooks for event notifications

There is no SDK. You use normal HTTP requests.

 

Integration Pattern Inside Bolt.new

 

The integration uses the standard Bolt.new pattern:

• You place your LearnWorlds API key in Bolt.new environment variables (never hardcoded).
• You make fetch or axios REST calls from server-side routes (Node.js) in your Bolt project.
• If you want LearnWorlds to notify you when something happens (user created, purchase complete), you expose a webhook endpoint inside Bolt.

No magic. Just HTTP.

 

The Minimal Working Example

 

This example shows exactly how you'd call LearnWorlds from inside a Bolt.new Node.js backend route. This is valid, working code.

// Example: server/routes/learnworlds.js

import express from "express"
import fetch from "node-fetch"

const router = express.Router()

router.post("/lw/create-user", async (req, res) => {
  try {
    const apiKey = process.env.LEARNWORLDS_API_KEY // store it in Bolt.new env vars
    const { email, firstName, lastName } = req.body

    const response = await fetch("https://api.learnworlds.com/v2/users", {
      method: "POST",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        email: email,
        first_name: firstName,
        last_name: lastName
      })
    })

    const data = await response.json()
    res.send(data)
  } catch (err) {
    res.status(500).send({ error: err.message })
  }
})

export default router

This is exactly how it works: Bolt.new hosts the code, you call the LearnWorlds API, and you return the result to your client.

 

Adding LearnWorlds Webhooks in Bolt.new

 

If you want LearnWorlds to notify your Bolt app about events (completed course, new purchase, new user), you expose a simple route:

// Example: server/routes/webhooks.js

import express from "express"
const router = express.Router()

router.post("/webhooks/learnworlds", async (req, res) => {
  // LearnWorlds sends JSON event payloads here
  const event = req.body

  // process event
  console.log("Received LearnWorlds webhook:", event)

  res.status(200).send({ received: true })
})

export default router

In LearnWorlds dashboard, you paste your Bolt route URL (the deploy URL) as the webhook target.

 

Correct Authentication Setup

 

LearnWorlds uses simple Bearer API keys. In Bolt.new:

• Open project settings
• Add an environment variable like LEARNWORLDS_API_KEY
• Reference it from server-side code only

This keeps your key safe and out of the frontend bundle.

 

Typical Things Teams Integrate

 

Most Bolt.new + LearnWorlds projects implement some or all of this:

• Custom user onboarding → create LearnWorlds user automatically
• Assign courses upon signup → call course enrollment endpoint
• Sync LearnWorlds progress → handle webhook events
• Custom dashboards → call LearnWorlds APIs to fetch course data
• Purchase → call LearnWorlds purchase or enrollment APIs

All of these are REST calls from Node.js routes.

 

Putting It All Together

 

To “integrate Bolt.new AI with LearnWorlds”, you:

• Use Bolt.new as a workspace to scaffold an app
• Add backend routes that call LearnWorlds API
• Store API keys in Bolt’s environment variables
• Optionally add webhooks for real-time LearnWorlds events

That’s the real, working, production-safe way to integrate the systems. No proprietary connectors or hidden steps — just standard HTTP APIs running from your Bolt.new server files.