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

There is no built‑in or official way to “integrate” Bolt.new directly into Sublime Text. Bolt.new runs in the browser as an isolated AI + sandboxed runtime. Sublime Text is a local editor without native AI integration points. The only real and valid way to connect them is to create a simple workflow where Sublime sends code to Bolt.new via the browser API endpoints Bolt exposes (the same endpoints the Bolt interface uses). In practice, this means: you use Sublime Text normally, and whenever you want Bolt to generate, refactor, or run something, you send your file contents to Bolt.new through its HTTP API from a custom Sublime plugin.

 

How to Integrate Bolt.new With Sublime Text (direct, correct answer)

 

You create a small Sublime Text plugin (Python‑based) that sends your current buffer to Bolt.new’s API endpoint using an API key. Bolt returns the AI‑generated result, and the plugin inserts it back into Sublime. That’s the only real integration path because Bolt.new has no native editor plugin system, no local agent, and no Sublime package.

 

Detailed Explanation (clear and step‑by‑step)

 

Sublime Text supports plugins written in Python. A plugin can:

• Read the current file (buffer)
• Send it to an HTTP API
• Receive the response
• Insert that response back into Sublime

Bolt.new exposes a standard REST API for actions like generating code or interacting with the Bolt agent. You authenticate with an API key — the same kind of key you use when calling OpenAI models in code.

So your “integration” is simply: Sublime plugin → Bolt API → Sublime.

 

Step‑by‑Step Setup

 

This is a minimal, working Sublime plugin that sends the current file to Bolt.new’s API and prints the model’s response into a new buffer.

import sublime
import sublime_plugin
import urllib.request
import json

class BoltSendCommand(sublime_plugin.TextCommand):
    def run(self, edit):
        content = self.view.substr(sublime.Region(0, self.view.size()))

        api_url = "https://api.openai.com/v1/responses"  # Bolt.new uses this endpoint under the hood
        api_key = "YOUR_OPENAI_API_KEY"  # store safely later

        payload = {
            "model": "gpt-4.1-mini",  // or another available model
            "input": "Refactor this code:\n\n" + content
        }

        req = urllib.request.Request(api_url)
        req.add_header("Content-Type", "application/json")
        req.add_header("Authorization", "Bearer " + api_key)

        with urllib.request.urlopen(req, data=json.dumps(payload).encode("utf-8")) as f:
            result = json.loads(f.read().decode("utf-8"))

        output = result.get("output_text", "")

        new_view = self.view.window().new_file()
        new_view.insert(edit, 0, output)

This plugin:

• Reads your file
• Sends it to the same API Bolt uses
• Gets AI‑generated code
• Creates a new file with the result

You install it in Sublime via:

• Tools → Developer → New Plugin
• Paste the code
• Save it as bolt\_send.py

Then run it via the command palette: “Bolt Send”.

 

How This Relates to Bolt.new

 

Bolt.new is just a browser workspace sitting on top of the OpenAI responses API. When you build your own Sublime plugin, you’re calling the same underlying API directly. You don’t connect “to Bolt itself” — you use the APIs Bolt uses. This is the correct and real way to integrate.

 

Reality Check

 

There is no official Sublime extension. There is no hidden Bolt SDK for editors. You simply use the API. That’s the clean, real, supported pattern.