How to Integrate Replit with Toggl

1import os
2import requests
3from datetime import datetime, timezone, timedelta
4
5API_TOKEN = os.environ["TOGGL_API_TOKEN"]
6WORKSPACE_ID = int(os.environ["TOGGL_WORKSPACE_ID"])
7
8BASE_URL = "https://api.track.toggl.com/api/v9"
9
10# Toggl uses Basic Auth: API token as username, 'api_token' as password (literal string)
11AUTH = (API_TOKEN, "api_token")
12HEADERS = {"Content-Type": "application/json"}
13
14def get_me() -> dict:
15    """Get current user info and default workspace ID."""
16    response = requests.get(f"{BASE_URL}/me", auth=AUTH)
17    response.raise_for_status()
18    return response.json()
19
20def get_workspaces() -> list:
21    """List all workspaces."""
22    response = requests.get(f"{BASE_URL}/workspaces", auth=AUTH)
23    response.raise_for_status()
24    return response.json()
25
26def get_projects() -> list:
27    """List all projects in the workspace."""
28    url = f"{BASE_URL}/workspaces/{WORKSPACE_ID}/projects"
29    response = requests.get(url, auth=AUTH, params={"active": "true"})
30    response.raise_for_status()
31    return response.json() or []
32
33def get_clients() -> list:
34    """List all clients in the workspace."""
35    url = f"{BASE_URL}/workspaces/{WORKSPACE_ID}/clients"
36    response = requests.get(url, auth=AUTH)
37    response.raise_for_status()
38    return response.json() or []
39
40def create_time_entry(
41    description: str,
42    start: datetime,
43    end: datetime,
44    project_id: int = None,
45    billable: bool = False,
46    tags: list = None
47) -> dict:
48    """
49    Create a completed time entry.
50    duration is calculated automatically from start and end.
51    start and end must be timezone-aware datetime objects.
52    """
53    duration_seconds = int((end - start).total_seconds())
54    data = {
55        "description": description,
56        "start": start.isoformat(),
57        "duration": duration_seconds,
58        "workspace_id": WORKSPACE_ID,
59        "created_with": "replit-integration",
60        "billable": billable
61    }
62    if project_id:
63        data["project_id"] = project_id
64    if tags:
65        data["tags"] = tags
66
67    url = f"{BASE_URL}/workspaces/{WORKSPACE_ID}/time_entries"
68    response = requests.post(url, json=data, auth=AUTH, headers=HEADERS)
69    response.raise_for_status()
70    return response.json()
71
72def start_timer(description: str, project_id: int = None) -> dict:
73    """
74    Start a running timer.
75    Toggl represents running timers with duration = -(Unix timestamp of start).
76    """
77    start = datetime.now(timezone.utc)
78    start_unix = int(start.timestamp())
79    data = {
80        "description": description,
81        "start": start.isoformat(),
82        "duration": -start_unix,  # Negative Unix timestamp = running timer
83        "workspace_id": WORKSPACE_ID,
84        "created_with": "replit-integration"
85    }
86    if project_id:
87        data["project_id"] = project_id
88
89    url = f"{BASE_URL}/workspaces/{WORKSPACE_ID}/time_entries"
90    response = requests.post(url, json=data, auth=AUTH, headers=HEADERS)
91    response.raise_for_status()
92    return response.json()
93
94def stop_timer(entry_id: int) -> dict:
95    """Stop a running timer by patching its end time."""
96    stop_time = datetime.now(timezone.utc)
97    url = f"{BASE_URL}/workspaces/{WORKSPACE_ID}/time_entries/{entry_id}/stop"
98    response = requests.patch(url, auth=AUTH, headers=HEADERS)
99    response.raise_for_status()
100    return response.json()
101
102def get_current_timer() -> dict:
103    """Get the currently running timer (if any)."""
104    response = requests.get(f"{BASE_URL}/me/time_entries/current", auth=AUTH)
105    if response.status_code == 200 and response.text != 'null':
106        return response.json()
107    return None
108
109def get_recent_entries(days: int = 7) -> list:
110    """Fetch time entries from the past N days."""
111    end = datetime.now(timezone.utc)
112    start = end - timedelta(days=days)
113    params = {
114        "start_date": start.isoformat(),
115        "end_date": end.isoformat()
116    }
117    response = requests.get(f"{BASE_URL}/me/time_entries", auth=AUTH, params=params)
118    response.raise_for_status()
119    return response.json() or []
120
121# Example usage
122if __name__ == "__main__":
123    me = get_me()
124    print(f"Connected as: {me['fullname']} ({me['email']})")
125
126    projects = get_projects()
127    print(f"Projects: {[p['name'] for p in projects[:5]]}")
128
129    # Log a 1-hour completed entry
130    end_time = datetime.now(timezone.utc)
131    start_time = end_time - timedelta(hours=1)
132    entry = create_time_entry(
133        description="Integration setup",
134        start=start_time,
135        end=end_time,
136        billable=True
137    )
138    print(f"Time entry created: {entry['id']} — {entry['description']}")

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const API_TOKEN = process.env.TOGGL_API_TOKEN;
8const WORKSPACE_ID = process.env.TOGGL_WORKSPACE_ID;
9
10// Both APIs use the same Basic Auth
11const AUTH = { username: API_TOKEN, password: 'api_token' };
12
13const togglApi = axios.create({
14  baseURL: 'https://api.track.toggl.com/api/v9',
15  auth: AUTH
16});
17
18const reportsApi = axios.create({
19  baseURL: 'https://reports.track.toggl.com/api/v3',
20  auth: AUTH
21});
22
23// Get all active projects
24app.get('/projects', async (req, res) => {
25  try {
26    const response = await togglApi.get(`/workspaces/${WORKSPACE_ID}/projects`, {
27      params: { active: 'true' }
28    });
29    res.json(response.data || []);
30  } catch (err) {
31    res.status(err.response?.status || 500).json({ error: err.message });
32  }
33});
34
35// Get summary report: hours per project for a date range
36// Query params: startDate (YYYY-MM-DD), endDate (YYYY-MM-DD)
37app.get('/reports/summary', async (req, res) => {
38  const { startDate, endDate } = req.query;
39  if (!startDate || !endDate) {
40    return res.status(400).json({ error: 'startDate and endDate are required (YYYY-MM-DD)' });
41  }
42  try {
43    const response = await reportsApi.post(
44      `/workspace/${WORKSPACE_ID}/summary/time_entries`,
45      {
46        start_date: startDate,
47        end_date: endDate,
48        grouping: 'projects',
49        sub_grouping: 'users'
50      }
51    );
52    // Format: map project groups to readable names
53    const summary = (response.data.groups || []).map(group => ({
54      project: group.title || 'No Project',
55      totalSeconds: group.seconds || 0,
56      totalHours: ((group.seconds || 0) / 3600).toFixed(2),
57      users: (group.sub_groups || []).map(sg => ({
58        user: sg.title,
59        hours: (sg.seconds / 3600).toFixed(2)
60      }))
61    }));
62    res.json(summary);
63  } catch (err) {
64    console.error('Reports error:', err.response?.data);
65    res.status(err.response?.status || 500).json({ error: err.message });
66  }
67});
68
69// Get detailed time entries report
70app.get('/reports/detailed', async (req, res) => {
71  const { startDate, endDate, projectId } = req.query;
72  if (!startDate || !endDate) {
73    return res.status(400).json({ error: 'startDate and endDate are required' });
74  }
75  try {
76    const body = {
77      start_date: startDate,
78      end_date: endDate,
79      order_by: 'date',
80      order_dir: 'DESC'
81    };
82    if (projectId) body.project_ids = [parseInt(projectId)];
83
84    const response = await reportsApi.post(
85      `/workspace/${WORKSPACE_ID}/search/time_entries`,
86      body
87    );
88    res.json(response.data || []);
89  } catch (err) {
90    res.status(err.response?.status || 500).json({ error: err.message });
91  }
92});
93
94// Create a time entry
95app.post('/time-entries', async (req, res) => {
96  const { description, start, end, projectId, billable } = req.body;
97  if (!description || !start || !end) {
98    return res.status(400).json({ error: 'description, start, and end are required' });
99  }
100  const startDate = new Date(start);
101  const endDate = new Date(end);
102  const durationSeconds = Math.round((endDate - startDate) / 1000);
103
104  try {
105    const response = await togglApi.post(`/workspaces/${WORKSPACE_ID}/time_entries`, {
106      description,
107      start: startDate.toISOString(),
108      duration: durationSeconds,
109      workspace_id: parseInt(WORKSPACE_ID),
110      project_id: projectId ? parseInt(projectId) : undefined,
111      billable: billable !== false,
112      created_with: 'replit-integration'
113    });
114    res.status(201).json(response.data);
115  } catch (err) {
116    console.error('Create entry error:', err.response?.data);
117    res.status(err.response?.status || 500).json({ error: err.message });
118  }
119});
120
121app.listen(3000, '0.0.0.0', () => {
122  console.log('Toggl Track integration server running on port 3000');
123});

1import os
2import time
3import schedule
4import requests
5from datetime import datetime, timezone, timedelta
6
7API_TOKEN = os.environ["TOGGL_API_TOKEN"]
8WORKSPACE_ID = int(os.environ["TOGGL_WORKSPACE_ID"])
9AUTH = (API_TOKEN, "api_token")
10REPORTS_URL = f"https://reports.track.toggl.com/api/v3/workspace/{WORKSPACE_ID}"
11
12def seconds_to_hm(seconds: int) -> str:
13    """Format seconds as H:MM."""
14    h = seconds // 3600
15    m = (seconds % 3600) // 60
16    return f"{h}h {m:02d}m"
17
18def generate_weekly_report():
19    """Generate a weekly summary report and print it."""
20    end_date = datetime.now(timezone.utc)
21    start_date = end_date - timedelta(days=7)
22
23    payload = {
24        "start_date": start_date.strftime("%Y-%m-%d"),
25        "end_date": end_date.strftime("%Y-%m-%d"),
26        "grouping": "projects",
27        "sub_grouping": "users"
28    }
29
30    response = requests.post(
31        f"{REPORTS_URL}/summary/time_entries",
32        json=payload,
33        auth=AUTH
34    )
35    response.raise_for_status()
36    data = response.json()
37
38    total_seconds = data.get('seconds', 0)
39    print(f"\n=== Weekly Report ({start_date.date()} to {end_date.date()}) ===")
40    print(f"Total time: {seconds_to_hm(total_seconds)}\n")
41
42    for group in data.get('groups', []):
43        project_name = group.get('title', 'No Project')
44        project_seconds = group.get('seconds', 0)
45        print(f"  {project_name}: {seconds_to_hm(project_seconds)}")
46        for sub in group.get('sub_groups', []):
47            print(f"    - {sub.get('title', 'Unknown')}: {seconds_to_hm(sub.get('seconds', 0))}")
48
49    print("\n" + "="*50)
50    # In production, send this to Slack or email:
51    # send_slack_message(format_report_for_slack(data))
52    # send_email_report(format_report_html(data))
53
54# Schedule to run every Monday at 8am UTC
55schedule.every().monday.at("08:00").do(generate_weekly_report)
56
57print("Toggl weekly report scheduler started.")
58print("Next run:", schedule.next_run())
59
60# Run immediately on startup for testing
61generate_weekly_report()
62
63while True:
64    schedule.run_pending()
65    time.sleep(60)  # Check every minute