Wakapi is a free, open source time & task management project written in Go and released under MIT. It has 4,433 GitHub stars, 300 forks and 39 open issues, and was last pushed 3 days ago. On this registry it ranks #6 of 13 tracked projects in Time & Task Management, with 5 head-to-head comparisons available. It gained 2 stars over the last 6 tracked days.

What is Wakapi?

What it is

Wakapi is a minimalist, self-hosted backend for coding statistics that speaks the WakaTime API. It is written in Go and released under the MIT license, and it lives in the developer-tools and productivity ecosystem alongside the WakaTime client tooling it is designed to work with. The project presents itself as a free and open-source alternative built by developers for developers, and it ships as a single service that collects, stores and visualizes time-tracking data sent from editors and IDEs.

The concrete problem it solves is ownership of coding-activity data. WakaTime's hosted service is the default destination for the WakaTime client plugins, but teams and individuals who want their statistics to stay on their own infrastructure need a compatible endpoint. Wakapi provides that endpoint: it is partially compatible with WakaTime, integrates with the existing WakaTime client tools, and exposes the collected data through its own web interface, REST API and Prometheus exports. That means existing editor plugins keep working while the data lands in a database the operator controls.

Key capabilities

  • Statistics broken down by project, language, editor, host and operating system.
  • Badges that can be embedded to display tracked metrics.
  • Weekly email reports summarizing activity.
  • A REST API for programmatic access to the collected data.
  • Prometheus export support for monitoring and dashboards.
  • Partial compatibility with the WakaTime API, plus integration with WakaTime client tooling.
  • Self-hosted deployment, with SQLite as the default database and MySQL or Postgres as alternatives.

Who uses it and how

  • Individual developers who run Wakapi on their own server and point their editor's WakaTime plugin at it via ~/.wakatime.cfg.
  • Teams that want shared coding statistics without sending data to a third-party cloud service.
  • Operators who deploy the container image ghcr.io/muety/wakapi:latest with a persistent volume and a password salt.
  • Users who prefer a managed option and create an account on the hosted service at wakapi.dev.
  • Kubernetes users who deploy through the community wakapi-helm-chart.

Getting started

The README lists four paths: a hosted cloud account at wakapi.dev, a quick-run release script via curl -L https://wakapi.dev/get | bash, a Docker container from ghcr.io/muety/wakapi:latest (also available through Docker Compose and Docker Secrets), or compiling from source with go install github.com/muety/wakapi@latest. In every case the client side still needs the open-source WakaTime client tools configured with the Wakapi api_url and api_key.

When to use it — and when not to

Wakapi is the right choice when the goal is a self-hosted, WakaTime-compatible backend and the operator is willing to run the service, a database (SQLite by default, or MySQL/Postgres) and optionally SMTP for the weekly email reports. Compared with the paid hosted product it replaces, it offers

project readme (upstream, from github) — read inline

A minimalist, self-hosted WakaTime-compatible backend for coding statistics.

Website | Features | How to use | Issues | Contact

[!IMPORTANT] Due to limited time available on the maintainers' part, we temporarily do not accept pull requests. Please refrain from submitting contributions for the time being.

🚀 Features

  • ✅ Free and open-source
  • ✅ Built by developers for developers
  • ✅ Statistics for projects, languages, editors, hosts and operating systems
  • ✅ Badges
  • ✅ Weekly E-Mail reports
  • ✅ REST API
  • ✅ Partially compatible with WakaTime
  • ✅ WakaTime integration
  • ✅ Support for Prometheus exports
  • ✅ Lightning fast
  • ✅ Self-hosted

⌨️ How to use?

There are different options for how to use Wakapi, ranging from our hosted cloud service to self-hosting it. Regardless of which option choose, you will always have to do the client setup in addition.

☁️ Option 1: Use wakapi.dev

If you want to try out a free, hosted cloud service, all you need to do is create an account and then set up your client-side tooling (see below).

📦 Option 2: Quick-run a release

$ curl -L https://wakapi.dev/get | bash

🐳 Option 3: Use Docker

# Create a persistent volume
$ docker volume create wakapi-data

$ SALT="$(cat /dev/urandom | LC_ALL=C tr -dc 'a-zA-Z0-9' | fold -w ${1:-32} | head -n 1)"

# Run the container
$ docker run -d \
  --init \
  -p 3000:3000 \
  -e "WAKAPI_PASSWORD_SALT=$SALT" \
  -v wakapi-data:/data \
  --name wakapi \
  --restart unless-stopped \
  ghcr.io/muety/wakapi:latest

Note: By default, SQLite is used as a database. To run Wakapi in Docker with MySQL or Postgres, see Dockerfile and config.default.yml for further options.

If you want to run Wakapi on Kubernetes, there is wakapi-helm-chart for quick and easy deployment.

Docker Compose

Alternatively, you can use Docker Compose for an even more straightforward deployment. See compose.yml for configuration details.

Wakapi supports Docker Secrets for the following variables: WAKAPI_PASSWORD_SALT, WAKAPI_DB_PASSWORD, WAKAPI_MAIL_SMTP_PASS. You can set these either by having them mounted as a secret file, or directly pass them as environment variables.

Example
export WAKAPI_PASSWORD_SALT=changeme
export WAKAPI_DB_PASSWORD=changeme
export WAKAPI_MAIL_SMTP_PASS=changeme

docker compose up -d

If you prefer to persist data in a local directory while using SQLite as the database, make sure to set the correct user option in the Docker Compose configuration to avoid permission issues.

🧑‍💻 Option 4: Compile and run from source

# Build and install
# Alternatively: go build -o wakapi
$ go install github.com/muety/wakapi@latest

# Get default config and customize
$ curl -o wakapi.yml https://raw.githubusercontent.com/muety/wakapi/master/config.default.yml
$ vi wakapi.yml

# Run it
$ ./wakapi -config wakapi.yml

Note: Check the comments in config.yml for best practices regarding security configuration and more.

💡 When running Wakapi standalone (without Docker), it is recommended to run it as a SystemD service.

💻 Client setup

Wakapi relies on the open-source WakaTime client tools. In order to collect statistics for Wakapi, you need to set them up.

  1. Set up WakaTime for your specific IDE or editor. Please refer to the respective plugin guide
  2. Edit your local ~/.wakatime.cfg file as follows.
[settings]

# Your Wakapi server URL or 'https://wakapi.dev/api' when using the cloud server
api_url = http://localhost:3000/api

# Your Wakapi API key (get it from the web interface after having created an account)
api_key = 406fe41f-6d69-4183-a4cc-121e0c524c2b

Optionally, you can set up a client-side proxy in addition.

WakaTime integration

You can use WakaTime and Wakapi in parallel, that is, have your coding activity tracked in both systems. This can be configured either on the client-side (preferred) on a system-wide- or per-project basis or using Wakapi's relay functionality (Settings → Integrations) to forward heartbeats to WakaTime.

Example:

[settings]
api_key = waka-api-key

[api_urls]
.* = https://wakapi.dev/api|wakapi-api-key

The API key in [settings] is used for WakaTime's default API, while [api_urls] defines additional destinations. Do not add multiple .* entries because duplicate keys are invalid in an INI file and are ignored by wakatime-cli.

See wakatime-cli usage for details.

🔧 Configuration options

You can specify configuration options either via a config file (default: config.yml, customizable through the -c argument) or via environment variables. Here is an overview of all options.

YAML key / Env. variable Default Description
env /
ENVIRONMENT
dev Whether to use development- or production settings
app.leaderboard_enabled /
WAKAPI_LEADERBOARD_ENABLED
true Whether to enable the public leaderboard
app.leaderboard_scope /
WAKAPI_LEADERBOARD_SCOPE
7_days Aggregation interval for public leaderboard (see here for allowed values)
app.leaderboard_generation_time /
WAKAPI_LEADERBOARD_GENERATION_TIME
0 0 6 * * *,0 0 18 * * * One or multiple times of day at which to re-calculate the leaderboard
app.leaderboard_require_auth /
WAKAPI_LEADERBOARD_REQUIRE_AUTH
false Restrict leaderboard access to logged in users only

readme truncated — read the full docs on github

Frequently asked questions

Is Wakapi free to use?

Wakapi is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Wakapi do?

Track coding time effortlessly, gain insights instantly

What is Wakapi written in?

Wakapi is primarily written in Go. Its source is publicly available at https://github.com/muety/wakapi, and it has 4,433 GitHub stars.