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

You integrate Bolt.new with Ghost by letting your Bolt.new project act like any other external app talking to Ghost’s REST Admin API. Bolt.new itself does not “plug into” Ghost — instead, you write code inside Bolt.new (server route, job, script, or full stack app) that sends authenticated requests to your Ghost instance using a real Admin API key. Ghost exposes a stable HTTPS API; Bolt.new can call it directly using fetch. Authentication uses Ghost’s Admin API key encoded as a JWT. Once you generate that JWT, Bolt.new can create posts, update posts, upload images, or trigger automations on your Ghost blog.

 

What Integration Actually Looks Like

 

You will not find any “official Bolt ↔ Ghost integration”. The real integration is simply: Bolt.new code calling Ghost Admin API endpoints with a valid JWT.

Ghost provides two APIs:

• Content API – read-only; cannot create or edit posts.
• Admin API – full read/write access; requires generating a JWT from an Admin API key.

To integrate Bolt.new AI with Ghost, you will use the Admin API.

 

Step‑by‑Step: Connecting Bolt.new to Ghost

 

Here’s the reliable path that always works:

• Create Admin API Key inside Ghost Admin → Settings → Integrations → “Add custom integration”. Copy the Admin API Key (format: key:secret).
• Store it as environment variable in your Bolt.new workspace (for example GHOST_ADMIN_KEY and GHOST_API_URL).
• Generate a JWT inside Bolt.new using the secret from the Admin Key. Ghost requires a specific JWT header/body structure.
• Use fetch from Bolt.new to call Ghost’s Admin API endpoints to create/update content.

 

Working JWT + Post Creation Example (valid code)

 

This is a complete minimal Node server snippet you can drop into Bolt.new. It uses the official, documented Ghost Admin JWT pattern:

import express from "express";
import jwt from "jsonwebtoken";

const app = express();
app.use(express.json());

// Load environment variables in Bolt.new
const [key, secret] = process.env.GHOST_ADMIN_KEY.split(':'); 
const ghostUrl = process.env.GHOST_API_URL; 
// Example envs:
// GHOST_ADMIN_KEY = "admin_id:abcdef0123456789abcdef0123456789"
// GHOST_API_URL   = "https://your-ghost-site.com"

app.post("/publish", async (req, res) => {
  try {
    // Build JWT required by Ghost Admin API
    const token = jwt.sign(
      {
        kid: key
      },
      Buffer.from(secret, 'hex'),
      {
        algorithm: 'HS256',
        expiresIn: '5m',
        audience: `${ghostUrl}/ghost/api/admin/`
      }
    );

    // Example: create a post
    const response = await fetch(`${ghostUrl}/ghost/api/admin/posts/`, {
      method: "POST",
      headers: {
        "Authorization": `Ghost ${token}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        posts: [
          {
            title: "Hello from Bolt.new",
            html: "<p>This post was created via the Ghost Admin API.</p>",
            status: "published"
          }
        ]
      })
    });

    const json = await response.json();
    res.json(json);

  } catch (err) {
    console.error(err);
    res.status(500).send("Failed");
  }
});

app.listen(3000, () => console.log("Server running"));

 

Explanation in Simple Terms

 

You’re doing three things:

• Ghost gives you a secret key so your code can prove who it is.
• In Bolt.new, you generate a small signed message (a JWT) using that key. That JWT expires quickly and must be re-generated for each call.
• Then you send HTTP requests to Ghost with this JWT in the Authorization header.

That’s it. This is the whole integration.

 

Hardening for Production

 

• Never expose the Admin Key on the client. Only use it server-side in Bolt.new.
• Limit what your integration does by creating Ghost custom integrations per environment (dev/stage/prod).
• Use environment variables both in Bolt.new and later in your actual deployment environment.
• Log Ghost API responses because Ghost returns highly useful structured errors.

 

What You Can Build With This Connection

 

• AI-generated blog posts published automatically.
• Scheduled content pipelines (Bolt.new cron job → Ghost API).
• AI editor tools that update drafts.
• Importing old content into Ghost at scale.

 

This is the real, correct, and production-safe way to integrate Bolt.new AI with Ghost.