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

To integrate Bolt.new with Infusionsoft by Keap, you do not connect “Bolt-to-Keap” directly. Instead, you build a normal full‑stack app inside Bolt.new (Node/Express, React, etc.), and inside that app you integrate with Keap using Keap’s official OAuth2 + REST API. Bolt.new is just your development environment. The real integration is your backend making authenticated HTTPS requests to Keap’s API using tokens you obtain through OAuth. That’s the whole model.

So: You create a Keap developer app → get Client ID/Secret → implement OAuth inside your Bolt.new backend → store access/refresh tokens via environment variables → call Keap’s REST endpoints → test them using the Bolt.new server. That’s the direct answer.

 

What Infusionsoft (Keap) Offers Technically

 

• Keap uses OAuth2 authentication. You must implement an OAuth “authorization code” flow.
• API is REST/JSON over HTTPS.
• You must store a refresh token because Keap access tokens expire in 24 hours.
• All calls use Bearer access tokens in the Authorization header.

 

How You Integrate Keap from a Bolt.new App

 

Bolt.new gives you a sandboxed Node environment where your backend can run. You integrate Keap the same way you would in a traditional Node/Express app — by calling external HTTP APIs and handling OAuth.

Here’s the real, working process:

• Create a Keap Developer App at https://developer.keap.com
• Register your OAuth redirect URL. In Bolt.new, use something like:
  https://YOUR-BOLT-URL/api/auth/keap/callback
• Save Client ID + Client Secret in Bolt.new environment variables.
• Implement OAuth login route + callback route.
• Exchange authorization code for access + refresh tokens.
• Store tokens in memory or a small local file for development; switch to a database for production.
• Use tokens to call Keap API endpoints (e.g., create contact, read tags, etc.).

 

Example: Node/Express OAuth + API Call (Valid, Real Code)

 

// server.js
import express from "express";
import fetch from "node-fetch"; // If using Node < 18
import dotenv from "dotenv";

dotenv.config();

const app = express();

// Step 1: Redirect user to Keap OAuth screen
app.get("/api/auth/keap", (req, res) => {
  const redirect = encodeURIComponent(process.env.KEAP_REDIRECT_URI);
  const url =
    "https://accounts.keap.com/app/oauth/authorize" +
    `?client_id=${process.env.KEAP_CLIENT_ID}` +
    `&redirect_uri=${redirect}` +
    "&response_type=code";

  res.redirect(url);
});

// Step 2: OAuth callback - exchange code for tokens
app.get("/api/auth/keap/callback", async (req, res) => {
  const code = req.query.code;

  const tokenRes = await fetch("https://api.infusionsoft.com/token", {
    method: "POST",
    headers: {
      Authorization:
        "Basic " +
        Buffer.from(
          process.env.KEAP_CLIENT_ID + ":" + process.env.KEAP_CLIENT_SECRET
        ).toString("base64"),
      "Content-Type": "application/x-www-form-urlencoded",
    },
    body: new URLSearchParams({
      grant_type: "authorization_code",
      code,
      redirect_uri: process.env.KEAP_REDIRECT_URI,
    }),
  });

  const tokens = await tokenRes.json();

  // Save tokens for dev (in real production store securely!)
  global.keapTokens = tokens;

  res.send("Keap Auth Success. Tokens stored.");
});

// Example: Use token to fetch contacts
app.get("/api/keap/contacts", async (req, res) => {
  const { access_token } = global.keapTokens || {};

  if (!access_token) {
    return res.status(401).json({ error: "Not authenticated with Keap" });
  }

  const apiRes = await fetch(
    "https://api.infusionsoft.com/crm/rest/v1/contacts",
    {
      headers: {
        Authorization: `Bearer ${access_token}`,
      },
    }
  );

  const data = await apiRes.json();
  res.json(data);
});

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

 

Essential Environment Variables in Bolt.new

 

• KEAP_CLIENT_ID
• KEAP_CLIENT_SECRET
• KEAP_REDIRECT_URI

In Bolt.new, add these in the “Environment Variables” panel so they are available to the Node process at runtime.

 

How to Use This in the Bolt.new Editor

 

• Create a server file (like server.js).
• Add the above routes.
• Run the development server inside Bolt.new.
• Visit /api/auth/keap to start the OAuth login and approve your app.
• Keap redirects back to your callback route and tokens become available.
• Call your new endpoint /api/keap/contacts to confirm integration works.

 

Hardening for Production (Outside Bolt)

 

• Never store tokens in memory; use a database or secure secret store.
• Implement automatic token refresh (Keap gives you a refresh token that lasts longer).
• Secure your API routes with auth (JWT, session, etc.).
• Use HTTPS for all deployed environments.

 

Main Takeaway

 

You do not “integrate Bolt.new with Keap”. You build a normal backend inside Bolt.new, and that backend integrates with Keap via OAuth2 and REST API calls. Bolt.new is only the workspace; Keap integration is just standard HTTPS plus OAuth.