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

To integrate Bolt.new AI with Keap, you don’t “connect bolt to Keap” directly — instead, you build a normal full‑stack app inside bolt.new (Node/Express, Next.js API routes, or similar), and that app talks to Keap using Keap’s REST API with proper OAuth2 authentication. Bolt.new is just the workspace; the integration happens through API calls your app makes from inside the Bolt sandbox. The core steps are: create a Keap OAuth app, store your Keap Client ID/Secret in bolt environment variables, implement the OAuth token exchange in your API route, persist the access/refresh token, and call Keap’s REST endpoints (contacts, tags, automations, etc.). That’s it — it’s a standard OAuth2 + REST API integration.

 

What you actually need to do

 

You integrate Keap by treating it as a normal external service with a public REST API. Keap exposes endpoints like /contacts, /opportunities, /tags, etc. The only tricky piece is the OAuth2 flow.

• Bolt.new cannot “auto-connect” to Keap. You must write the API integration yourself.
• You use Keap’s OAuth2 to obtain an access_token and refresh_token.
• Your Bolt.new app stores CLIENT_ID, CLIENT_SECRET, and the tokens in its environment variables.
• Your API routes perform normal fetch calls to Keap’s REST endpoints.

 

Step-by-step: how to integrate

 

This is the exact practical flow you would implement inside bolt.new.

• Create a Keap Developer App at https://developer.infusionsoft.com.
• Set your OAuth redirect URL to something like https://your-bolt-project-url/api/keap/callback.
• Copy your Client ID and Client Secret.
• In bolt.new → Environment Variables, set:
  • KEAP_CLIENT_ID
  • KEAP_CLIENT_SECRET
  • KEAP_REDIRECT_URI
• Implement the OAuth handshake in an API route.
• Store refresh_token so you can renew access_token automatically.
• Call the Keap API from server-side (inside API routes, not client components).

 

Example: OAuth login route (Next.js API Route or Express)

 

// /api/keap/auth.js
// Step 1: Redirect user to Keap login

export default function handler(req, res) {
  const params = new URLSearchParams({
    client_id: process.env.KEAP_CLIENT_ID,
    redirect_uri: process.env.KEAP_REDIRECT_URI,
    response_type: "code",
    scope: "full"
  });

  res.redirect(`https://accounts.infusionsoft.com/app/oauth/authorize?${params}`);
}

 

Example: OAuth callback route (your redirect target)

 

// /api/keap/callback.js
// Step 2: Exchange code for access_token and refresh_token

export default async function handler(req, res) {
  const code = req.query.code;

  const body = new URLSearchParams({
    code,
    client_id: process.env.KEAP_CLIENT_ID,
    client_secret: process.env.KEAP_CLIENT_SECRET,
    grant_type: "authorization_code",
    redirect_uri: process.env.KEAP_REDIRECT_URI
  });

  const tokenResp = await fetch("https://api.infusionsoft.com/token", {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body
  });

  const tokens = await tokenResp.json();

  // In a real app, store tokens in DB or secure storage
  console.log("Keap tokens:", tokens);

  res.send("Keap connected. Tokens received.");
}

 

Example: Calling Keap API (fetch contacts)

 

// /api/keap/contacts.js
// Requires a valid access_token (from your stored tokens)

export default async function handler(req, res) {
  const accessToken = process.env.KEAP_ACCESS_TOKEN; // Store this after OAuth

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

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

 

Important realities to understand

 

Keap API access tokens always expire. You must refresh them via:

• POST https://api.infusionsoft.com/token with grant_type=refresh_token.
• Replace the old tokens with the new ones.

Bolt.new environment variables only persist in the project; for production deployments, move them to real environment config (like Vercel, Railway, etc.).

Bolt.new itself never stores Keap data — your app does. Bolt is just the workspace in which the full‑stack app runs.

 

What this gives you

 

• You can read and write Keap contacts, tags, opportunities, and automations.
• You can build internal tools or forms that push data into Keap.
• You can even set up webhook endpoints inside bolt.new (Keap supports outbound webhooks).

This is the correct, real, production-valid way to integrate Keap with an app built inside Bolt.new.