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

To integrate bolt.new with Propertybase, you do not connect to Propertybase “through Bolt itself.” Instead, you build a normal web backend inside bolt.new (Node.js/Next.js, Express, Python, etc.) and have that backend authenticate to Propertybase’s API. Propertybase is built on top of Salesforce, so the only fully reliable integration path is the Salesforce REST API or SOAP API, authenticated through either OAuth 2.0 (for user-facing apps) or a Salesforce Connected App + OAuth + refresh tokens (for server-side automation). Bolt doesn’t provide any special adapter for Propertybase — you simply write standard API calls, store secrets in environment variables, and test endpoints in bolt.new’s sandbox.

 

What You Actually Do

 

You create a backend inside bolt.new that talks to Propertybase using Salesforce’s APIs. You authenticate using a Salesforce Connected App, then call the REST endpoints to read or write Propertybase objects (Contacts, Listings, Leads, etc.). bolt.new’s role is just to let you scaffold and test this flow quickly, but the integration itself uses Salesforce-standard OAuth and REST calls.

 

How to Do It (step‑by‑step, but not numbered)

 

• Create a Salesforce Connected App inside the Propertybase org. This gives you: client_id, client_secret, callback URL, and permission scopes.
• Inside bolt.new, create a backend (for example Node.js with Express or Next.js API routes).
• Add your client_id, client_secret, username/password (if using username-password OAuth flow), or refresh\_token to bolt.new environment variables.
• Implement the standard Salesforce OAuth token exchange endpoint to obtain an access\_token.
• Use the access\_token to call Propertybase objects through the /services/data/vXX.X/sobjects/ REST endpoints.

 

Minimal Working Example (Node.js Express inside bolt.new)

 

This uses the Salesforce username-password OAuth flow (works for backend-only prototypes). For production, you normally switch to refresh tokens.

 

// server.js
// Express app to authenticate to Propertybase (Salesforce) and fetch a Contact record

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

const app = express();

app.get("/pb/contact", async (req, res) => {
  try {
    // Values pulled from bolt.new Env Vars panel
    const params = new URLSearchParams();
    params.append("grant_type", "password");
    params.append("client_id", process.env.SF_CLIENT_ID);
    params.append("client_secret", process.env.SF_CLIENT_SECRET);
    params.append("username", process.env.SF_USERNAME);
    params.append("password", process.env.SF_PASSWORD); // password + security token if required

    // Authenticate with Salesforce/Propertybase
    const tokenResp = await fetch("https://login.salesforce.com/services/oauth2/token", {
      method: "POST",
      body: params
    });
    const tokenJson = await tokenResp.json();

    // Use the access_token + instance_url to call Propertybase objects
    const contactResp = await fetch(
      tokenJson.instance_url + "/services/data/v60.0/sobjects/Contact/describe",
      {
        headers: {
          Authorization: "Bearer " + tokenJson.access_token
        }
      }
    );

    const data = await contactResp.json();
    res.json(data);

  } catch (err) {
    console.error(err);
    res.status(500).send("Error contacting Propertybase");
  }
});

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

 

Important Details

 

• Propertybase does not expose a separate API. It exposes Salesforce objects and custom Propertybase-managed objects via the standard Salesforce REST API.
• Your org may require a Security Token appended to the password in the username-password flow.
• In bolt.new you store secrets using the Env Vars panel so they’re not hard‑coded.
• If your integration is user-facing, you normally use the OAuth “authorization code” flow instead of the username-password flow.

 

How You Harden This Outside bolt.new

 

• Use the OAuth refresh-token flow instead of username-password.
• Store secrets in a secret manager (AWS Secrets Manager, GCP Secret Manager, Vault, etc.).
• Implement retry logic because Salesforce APIs rate‑limit.
• Log all API failures; Salesforce error objects contain helpful text.

 

That is the complete real-world method: bolt.new runs your backend code; the backend authenticates against the Salesforce/Propertybase API via OAuth; you then call REST endpoints for Propertybase data. No hidden adapters, no magic — just standard Salesforce integration inside a bolt.new project.