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

You integrate Bolt.new with Time Doctor the same way you integrate any external SaaS in Bolt: by calling Time Doctor’s public REST API from code you write inside Bolt’s server-side environment. Bolt.new does not have a built‑in “Time Doctor connector.” You authenticate using a Time Doctor OAuth2 token or a Personal Access Token (depending on the Time Doctor account type), store it as an environment variable in Bolt, and then call Time Doctor’s API endpoints (for example, to fetch user activity, screenshots, time entries, etc.). Everything is done through standard HTTP requests using fetch() or an HTTP client.

 

What You Actually Do

 

You create a small backend route in Bolt.new (Node.js inside the /api folder). That route talks to Time Doctor’s REST API using your token. Then your frontend or your AI agent calls that backend route. That’s the entire integration pattern.

• No plugin system exists between Bolt and Time Doctor.
• Everything happens via REST API calls you write.
• Auth must be managed by you (typically OAuth2 or a Time Doctor PAT).
• Tokens go in Bolt environment variables to avoid exposing secrets.

 

How Time Doctor Authentication Works

 

Time Doctor offers two real auth methods (these are real, documented):

• OAuth2 – for apps you want to distribute or for accounts requiring user consent.
• Personal Access Token (PAT) – simpler; ideal for internal automations, service scripts, and Bolt prototypes.

If you are prototyping in Bolt.new, use the PAT method because it avoids needing OAuth callback routes and simplifies everything. You create it inside your Time Doctor account under Settings → Integrations → Developer API (this exists in Time Doctor 2 and Time Doctor Classic).

 

Set Environment Variables in Bolt.new

 

In your Bolt project → "Environment variables":

• TIME_DOCTOR_API\_TOKEN = your PAT token
• TIME_DOCTOR_COMPANY\_ID = (optional, but often necessary)

Bolt will inject these into process.env in your server-side code.

 

Basic Working Example: Fetching Time Doctor Worklogs from Bolt.new

 

This is a real, valid pattern. Time Doctor API endpoint example (Time Doctor 2): GET https://api.timedoctor.com/v2/companies/{company\_id}/worklogs

Inside Bolt.new, create a file: /api/timedoctor-worklogs.js

// This route runs server-side in Bolt.new
export default async function handler(req, res) {
  try {
    const token = process.env.TIME_DOCTOR_API_TOKEN;  // stored securely
    const companyId = process.env.TIME_DOCTOR_COMPANY_ID;

    const tdRes = await fetch(
      `https://api.timedoctor.com/v2/companies/${companyId}/worklogs`,
      {
        method: "GET",
        headers: {
          "Authorization": `Bearer ${token}`,
          "Content-Type": "application/json"
        }
      }
    );

    if (!tdRes.ok) {
      return res.status(tdRes.status).json({
        error: "Time Doctor API error",
        details: await tdRes.text()
      });
    }

    const data = await tdRes.json();
    return res.status(200).json(data);  // return to frontend or AI agent
  } catch (err) {
    return res.status(500).json({ error: "Unexpected error", details: err.message });
  }
}

 

How the Frontend or AI Agent Uses It

 

In the Bolt UI or any frontend page:

const loadWorklogs = async () => {
  const res = await fetch("/api/timedoctor-worklogs");
  const data = await res.json();
  console.log(data); // Now you can render or inspect the logs
};

 

Common Real-World Notes & Limits

 

• Rate limits: Time Doctor enforces rate limits. Add retries or backoff when hardening.
• CORS: You must call Time Doctor from the server side, not directly from frontend, because PATs must stay private.
• Pagination: Time Doctor endpoints often paginate results; check "page" and "per\_page" parameters.
• Time zones: Worklogs and screenshots use UTC timestamps—convert in frontend if needed.
• Screenshot API: Returns URLs requiring token-based access; don't expose them publicly.

 

If You Need OAuth2 Instead of PAT

 

Only use if your client requires user-consent or multi-user setup. In Bolt.new you create two backend routes:

• /api/auth/time-doctor/start – redirects user to Time Doctor OAuth authorization URL
• /api/auth/time-doctor/callback – Time Doctor returns a code, you exchange it for an access token

You store the resulting token in a DB or session. This is standard OAuth2; no proprietary tricks.

 

Final Integration Architecture

 

• Frontend or AI agent → calls your Bolt API routes
• Bolt API routes → call Time Doctor REST API with PAT / OAuth tokens
• Time Doctor → returns JSON → you use it in UI or AI flows

This is the clean, real, production-valid way to integrate Bolt.new with Time Doctor.