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

You integrate Bolt.new with Constant Contact the same way you integrate any app with Constant Contact: by calling Constant Contact’s REST API from Bolt.new’s backend code and authenticating with OAuth2 (or a long‑lived token if your Constant Contact account provides one). Bolt.new doesn’t have built‑in Constant Contact connectors, so you wire it manually using standard HTTP requests, store credentials in environment variables, and test the flows inside Bolt’s sandbox just like any other external integration.

 

How the Integration Actually Works

 

Constant Contact exposes a real, documented REST API. Bolt.new exposes a browser-based full‑stack workspace where you can run Node.js code in a server route. The integration is simply your Bolt.new backend calling Constant Contact’s API endpoints using fetch or axios, with correct authentication.

There is no special “Bolt → Constant Contact” connector. You build it the same way you would in a normal Node.js server.

 

Key Concepts Explained Simply

 

• REST API: Standard web URLs you send requests to (GET/POST/etc.). Constant Contact uses this.
• OAuth2: A secure login flow where your app gets a token proving permission to access a user’s Constant Contact data.
• Access Token: A secret that lets your server call Constant Contact. Stored in Bolt.new environment variables.
• Refresh Token: Used to get a new access token when it expires.
• Backend Route: A server file inside Bolt.new’s project (often /server/api/\*.ts) where your integration code runs.

 

Step-by-Step: Integrating Bolt.new with Constant Contact

 

Below is the real, correct sequence used in production and also when prototyping inside Bolt.new.

• Create a Constant Contact app in the Constant Contact developer portal. This gives you a Client ID, Client Secret, allowed redirect URLs, and scopes you want (e.g. contacts:write).
• Add environment variables in bolt.new In Bolt.new workspace → Environment tab: You define:
  • CC_CLIENT_ID
  • CC_CLIENT_SECRET
  • CC_REDIRECT_URI
  • CC_ACCESS_TOKEN
  • CC_REFRESH_TOKEN
  Tokens will be empty initially until you do OAuth.
• Implement the OAuth redirect route in Bolt.new This is a backend route that Constant Contact redirects to after user login.
• Exchange authorization code for tokens After user signs in, Constant Contact sends a ?code=.... You exchange that for access/refresh tokens using a POST request.
• Store the tokens in environment variables and reuse them for API calls.
• Now you can call Constant Contact APIs from any server route in Bolt.new.

 

Example: OAuth Callback Route in Bolt.new (Node)

 

You’d create a backend route such as /server/api/cc-oauth.ts:

 

import { NextRequest, NextResponse } from "next/server";

export async function GET(req: NextRequest) {
  const url = new URL(req.url);
  const code = url.searchParams.get("code");

  if (!code) {
    return NextResponse.json({ error: "Missing OAuth code" }, { status: 400 });
  }

  // Exchange code for tokens
  const tokenRes = await fetch("https://authz.constantcontact.com/oauth2/default/v1/token", {
    method: "POST",
    headers: {
      "Content-Type": "application/x-www-form-urlencoded"
    },
    body: new URLSearchParams({
      grant_type: "authorization_code",
      code,
      redirect_uri: process.env.CC_REDIRECT_URI || "",
      client_id: process.env.CC_CLIENT_ID || "",
      client_secret: process.env.CC_CLIENT_SECRET || ""
    })
  });

  const tokenData = await tokenRes.json();

  // tokenData contains: access_token, refresh_token, expires_in, token_type
  // In real usage you'd persist it in DB or store it in your env manually.
  console.log("Received tokens:", tokenData);

  return NextResponse.json({ success: true, tokens: tokenData });
}

 

Example: Making a Real Constant Contact API Call from Bolt.new

 

Once you have an access token, you can add a contact like this (server-side only):

 

import { NextRequest, NextResponse } from "next/server";

export async function POST(req: NextRequest) {
  const accessToken = process.env.CC_ACCESS_TOKEN;

  if (!accessToken) {
    return NextResponse.json({ error: "Missing Constant Contact token" }, { status: 401 });
  }

  const body = await req.json(); // { email: "[email protected]" }

  const res = await fetch("https://api.cc.email/v3/contacts", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${accessToken}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      email_address: { address: body.email },
      create_source: "Account" // Required field
    })
  });

  const data = await res.json();
  return NextResponse.json(data);
}

 

Important Constraints and Limits

 

• Bolt.new cannot store tokens automatically. You must copy tokens into environment variables or use a database.
• Constant Contact tokens expire. You must implement refresh-token logic to rotate them.
• You cannot run OAuth on the frontend. Keep client secret only in backend routes.
• Bolt.new sandbox can call external APIs normally as long as the API supports standard HTTPS, which Constant Contact does.

 

A Simple Mental Model

 

Your Bolt.new backend is just a Node.js server. Constant Contact is just a REST API. You connect them by securely storing credentials, performing OAuth, and calling the API using fetch. Everything else is your UI and business logic layered on top.