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

You integrate Bolt.new with DeepAI the same way you integrate Bolt with any external API: you write a normal backend call inside the Bolt.new workspace (Node.js server), store your DeepAI API key as an environment variable, and then call DeepAI’s REST endpoints using fetch. Bolt itself does not have a “special connector” — you wire everything manually but quickly. DeepAI uses a simple HTTP POST with an API key in the header, so integration is straightforward.

 

What DeepAI Actually Provides

 

DeepAI exposes a set of REST endpoints such as text generation, image generation, image enhancement, semantic similarity, etc. You interact with them using a standard POST request, passing your API key in the Api-Key header. This is all you need to know to wire it into a Bolt.new backend.

 

How to Integrate DeepAI Inside Bolt.new

 

Below is the exact, reliable pattern you use inside Bolt.new’s backend (usually /api routes). This pattern is identical whether you call DeepAI for text, images, or anything else — only the endpoint and POST body change.

• Create a new Bolt project.
• Open the server file (usually server.ts or api/...route.ts depending on your template).
• Add your DeepAI API key in environment variables (Settings → Environment Variables in bolt.new).
• Write a backend function or route that calls DeepAI using fetch.
• Expose that backend route to your frontend or to your internal agent in bolt.

 

Working Node.js Example (Bolt.new backend)

 

// This example shows how to call DeepAI's Text Generator endpoint
// You can adapt it for any other DeepAI model by changing the URL and payload.

export async function POST(req: Request) {
  try {
    const { prompt } = await req.json();

    const response = await fetch("https://api.deepai.org/api/text-generator", {
      method: "POST",
      headers: {
        "Api-Key": process.env.DEEPAI_API_KEY!,   // stored in bolt.new env
        "Content-Type": "application/json"
      },
      body: JSON.stringify({ text: prompt })
    });

    const result = await response.json();

    return new Response(JSON.stringify(result), {
      status: 200,
      headers: { "Content-Type": "application/json" }
    });

  } catch (err) {
    return new Response(JSON.stringify({ error: String(err) }), { status: 500 });
  }
}

 

Frontend Example That Calls the API Route

 

// Example React code that calls the Bolt backend route you created.

async function generateFromDeepAI(prompt) {
  const res = await fetch("/api/deepai-text", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ prompt })
  });

  const data = await res.json();
  console.log("DeepAI result:", data);
  return data;
}

 

Important Integration Notes

 

• Bolt.new never sends your API key automatically — you must store it via environment variables.
• DeepAI requires no OAuth. It uses a simple static API key.
• Rate limits apply. DeepAI free tier is limited; handle HTTP 429 responses if needed.
• Do not call DeepAI directly from the browser, because that exposes your API key.
• All external calls must run through the Bolt.new backend to stay secure.

 

How This Fits Into Bolt Agents (optional explanation)

 

If you’re using Bolt Agents, remember that agents do not connect directly to DeepAI. Instead, they call your backend route (like /api/deepai-text), which then communicates with DeepAI. The agent only sees your API response, not the DeepAI key.

 

Summary

 

You integrate Bolt.new with DeepAI by writing a normal REST API call in your Bolt backend, passing the DeepAI API key via environment variables, and exposing a clean endpoint your UI or agent can call. Bolt adds no custom magic; you simply wire the call yourself — cleanly, securely, and predictably.