How to Integrate Replit with Clockify

1import os
2import requests
3from datetime import datetime, timezone, timedelta
4
5API_KEY = os.environ["CLOCKIFY_API_KEY"]
6WORKSPACE_ID = os.environ["CLOCKIFY_WORKSPACE_ID"]
7BASE_URL = "https://api.clockify.me/api/v1"
8
9# Clockify uses X-Api-Key header (not Authorization Bearer)
10HEADERS = {
11    "X-Api-Key": API_KEY,
12    "Content-Type": "application/json"
13}
14
15def get_workspaces() -> list:
16    """List all workspaces accessible with this API key."""
17    response = requests.get(f"{BASE_URL}/workspaces", headers=HEADERS)
18    response.raise_for_status()
19    return response.json()
20
21def get_projects() -> list:
22    """List all projects in the workspace."""
23    url = f"{BASE_URL}/workspaces/{WORKSPACE_ID}/projects"
24    response = requests.get(url, headers=HEADERS, params={"page-size": 200})
25    response.raise_for_status()
26    return response.json()
27
28def get_current_user() -> dict:
29    """Get the current authenticated user's info (includes userId)."""
30    response = requests.get(f"{BASE_URL}/user", headers=HEADERS)
31    response.raise_for_status()
32    return response.json()
33
34def create_time_entry(
35    start: datetime,
36    end: datetime,
37    project_id: str,
38    description: str = "",
39    billable: bool = True
40) -> dict:
41    """
42    Create a completed time entry.
43    start and end should be timezone-aware datetime objects.
44    """
45    data = {
46        "start": start.strftime("%Y-%m-%dT%H:%M:%SZ"),
47        "end": end.strftime("%Y-%m-%dT%H:%M:%SZ"),
48        "projectId": project_id,
49        "description": description,
50        "billable": billable
51    }
52    url = f"{BASE_URL}/workspaces/{WORKSPACE_ID}/time-entries"
53    response = requests.post(url, json=data, headers=HEADERS)
54    response.raise_for_status()
55    return response.json()
56
57def start_timer(project_id: str, description: str = "") -> dict:
58    """Start a running timer (no end time — Clockify tracks until stopped)."""
59    now = datetime.now(timezone.utc)
60    data = {
61        "start": now.strftime("%Y-%m-%dT%H:%M:%SZ"),
62        "projectId": project_id,
63        "description": description
64    }
65    url = f"{BASE_URL}/workspaces/{WORKSPACE_ID}/time-entries"
66    response = requests.post(url, json=data, headers=HEADERS)
67    response.raise_for_status()
68    return response.json()
69
70def stop_timer(user_id: str) -> dict:
71    """Stop the currently running timer for a user."""
72    now = datetime.now(timezone.utc)
73    url = f"{BASE_URL}/workspaces/{WORKSPACE_ID}/user/{user_id}/time-entries"
74    data = {"end": now.strftime("%Y-%m-%dT%H:%M:%SZ")}
75    response = requests.patch(url, json=data, headers=HEADERS)
76    response.raise_for_status()
77    return response.json()
78
79def get_time_entries(user_id: str, start: datetime, end: datetime) -> list:
80    """Fetch time entries for a user within a date range."""
81    url = f"{BASE_URL}/workspaces/{WORKSPACE_ID}/user/{user_id}/time-entries"
82    params = {
83        "start": start.strftime("%Y-%m-%dT%H:%M:%SZ"),
84        "end": end.strftime("%Y-%m-%dT%H:%M:%SZ"),
85        "page-size": 500
86    }
87    response = requests.get(url, params=params, headers=HEADERS)
88    response.raise_for_status()
89    return response.json()
90
91# Example usage
92if __name__ == "__main__":
93    user = get_current_user()
94    print(f"Connected as: {user['name']} ({user['email']})")
95
96    projects = get_projects()
97    print(f"Projects: {[p['name'] for p in projects[:5]]}")
98
99    if projects:
100        # Log a 2-hour entry for the first project
101        end_time = datetime.now(timezone.utc)
102        start_time = end_time - timedelta(hours=2)
103        entry = create_time_entry(start_time, end_time, projects[0]['id'], "Example task")
104        print(f"Time entry created: {entry['id']}")

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const API_KEY = process.env.CLOCKIFY_API_KEY;
8const WORKSPACE_ID = process.env.CLOCKIFY_WORKSPACE_ID;
9const BASE_URL = 'https://api.clockify.me/api/v1';
10
11// Axios instance with Clockify API key header
12const clockify = axios.create({
13  baseURL: BASE_URL,
14  headers: { 'X-Api-Key': API_KEY }
15});
16
17// Get current user (useful for retrieving userId)
18app.get('/user', async (req, res) => {
19  try {
20    const response = await clockify.get('/user');
21    res.json(response.data);
22  } catch (err) {
23    res.status(err.response?.status || 500).json({ error: err.message });
24  }
25});
26
27// List projects in the workspace
28app.get('/projects', async (req, res) => {
29  try {
30    const response = await clockify.get(
31      `/workspaces/${WORKSPACE_ID}/projects`,
32      { params: { 'page-size': 200 } }
33    );
34    res.json(response.data);
35  } catch (err) {
36    res.status(err.response?.status || 500).json({ error: err.message });
37  }
38});
39
40// Create a completed time entry
41app.post('/time-entries', async (req, res) => {
42  const { start, end, projectId, description, billable } = req.body;
43  if (!start || !end || !projectId) {
44    return res.status(400).json({ error: 'start, end, and projectId are required' });
45  }
46  try {
47    const response = await clockify.post(
48      `/workspaces/${WORKSPACE_ID}/time-entries`,
49      { start, end, projectId, description: description || '', billable: billable !== false }
50    );
51    res.status(201).json(response.data);
52  } catch (err) {
53    console.error('Time entry error:', err.response?.data);
54    res.status(err.response?.status || 500).json({ error: err.message });
55  }
56});
57
58// Get time entries for a user within a date range
59// Query params: userId, start (ISO), end (ISO)
60app.get('/time-entries', async (req, res) => {
61  const { userId, start, end } = req.query;
62  if (!userId || !start || !end) {
63    return res.status(400).json({ error: 'userId, start, and end are required' });
64  }
65  try {
66    const response = await clockify.get(
67      `/workspaces/${WORKSPACE_ID}/user/${userId}/time-entries`,
68      { params: { start, end, 'page-size': 500 } }
69    );
70    res.json(response.data);
71  } catch (err) {
72    res.status(err.response?.status || 500).json({ error: err.message });
73  }
74});
75
76// Stop running timer for a user
77app.post('/timers/stop', async (req, res) => {
78  const { userId } = req.body;
79  if (!userId) return res.status(400).json({ error: 'userId is required' });
80  const end = new Date().toISOString().replace('.000', '');
81  try {
82    const response = await clockify.patch(
83      `/workspaces/${WORKSPACE_ID}/user/${userId}/time-entries`,
84      { end }
85    );
86    res.json(response.data);
87  } catch (err) {
88    res.status(err.response?.status || 500).json({ error: err.message });
89  }
90});
91
92app.listen(3000, '0.0.0.0', () => {
93  console.log('Clockify integration server running on port 3000');
94});

1import os
2import requests
3from datetime import datetime, timezone, timedelta
4
5API_KEY = os.environ["CLOCKIFY_API_KEY"]
6WORKSPACE_ID = os.environ["CLOCKIFY_WORKSPACE_ID"]
7HEADERS = {"X-Api-Key": API_KEY, "Content-Type": "application/json"}
8REPORTS_URL = f"https://api.clockify.me/api/v1/workspaces/{WORKSPACE_ID}/reports"
9
10def get_summary_report(start_date: datetime, end_date: datetime) -> dict:
11    """
12    Get a summary report grouped by project.
13    Returns total hours per project for the date range.
14    """
15    payload = {
16        "dateRangeStart": start_date.strftime("%Y-%m-%dT00:00:00Z"),
17        "dateRangeEnd": end_date.strftime("%Y-%m-%dT23:59:59Z"),
18        "summaryFilter": {
19            "groups": ["PROJECT", "USER"]
20        },
21        "exportType": "JSON"
22    }
23    response = requests.post(f"{REPORTS_URL}/summary", json=payload, headers=HEADERS)
24    response.raise_for_status()
25    return response.json()
26
27def format_duration(seconds: int) -> str:
28    """Convert seconds to hours and minutes string."""
29    hours = seconds // 3600
30    minutes = (seconds % 3600) // 60
31    return f"{hours}h {minutes}m"
32
33if __name__ == "__main__":
34    # Generate weekly report
35    end = datetime.now(timezone.utc)
36    start = end - timedelta(days=7)
37
38    print(f"Time report: {start.date()} to {end.date()}\n")
39    report = get_summary_report(start, end)
40
41    for group in report.get('groupOne', []):
42        project_name = group.get('name', 'No Project')
43        total_seconds = group.get('duration', 0)
44        print(f"  {project_name}: {format_duration(total_seconds)}")
45
46        # Show per-user breakdown
47        for child in group.get('children', []):
48            user_name = child.get('name', 'Unknown')
49            user_seconds = child.get('duration', 0)
50            print(f"    - {user_name}: {format_duration(user_seconds)}")
51
52    total = report.get('totals', [{}])[0].get('totalTime', 0)
53    print(f"\nTotal: {format_duration(total)}")