# Cent: a shared accounting app that keeps its books in a GitHub repository

> A PWA that treats a private GitHub or Gitee repository as the database for a shared expense ledger, with incremental sync, WebDAV support and no backend of its own beyond an OAuth helper. The catch is the licence, Creative Commons BY-NC-SA 4.0, which forbids commercial use, and a self-hosted setup that requires you to paste a repo-scoped token.

**glink25/Cent** — 完全免费、开源的多人协作记账 Web App | Completely free, open-source, collaborative accounting Web App

- Repository: https://github.com/glink25/Cent
- Website: https://cent.linkai.work/
- Stars: 1,262 · Forks: 323
- Language: TypeScript
- License: NOASSERTION
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/glink25-cent

## A ledger where each book is a repository

Cent is a completely free, open source, collaborative accounting web app. The unusual part is stated in the core-principles section: it is a pure front end PWA, and apart from GitHub or Gitee OAuth login it depends on no backend service at all.

The data model explains how that works. Each ledger, called a Book, is a GitHub or Gitee repository. The data is stored as JSON in that repository, which means it supports history rollback, and books are identified by repository name, which is what makes multiple ledgers possible.

So the version control system is the database, and the commit history is the audit log. A change to a balance is a commit, and a mistake is a revert. That is an unusual and rather elegant fit for an expense tracker, where the history genuinely matters and where the data volume is small enough that a git repository is a reasonable container.

The collaborative side uses the GitHub Collaborator feature, so granting someone write access to the repository grants them access to the ledger. There is no separate permission model, no user table and no sharing UI to build, and equally no way to give someone read-only access to one category of spending.

The project is a PWA, installable to a desktop and usable like a native app, and there is also an iOS build on the App Store. The live version is at cent.linkai.work, and the licence is Creative Commons Attribution-NonCommercial-ShareAlike 4.0, which allows sharing and adaptation with attribution, requires derivative works to use the same licence, and prohibits commercial use.

## The incremental sync strategy

Since a repository can be large and a phone on a slow connection is not a good place to re-download one, the sync mechanism is the part of the design that carries the most weight.

Cent has a custom incremental sync strategy that transfers only the differences. The first sync downloads the data in full. Subsequent syncs transmit only the newly added or modified parts. It supports offline caching and resumable transfers.

The claim is that this significantly improves sync efficiency and makes the collaborative experience feel natural. The mechanism behind it is not described in the README, so how the diff is computed, and how two people editing the same file concurrently are reconciled, is not something the documentation answers.

That is the central technical risk of the project and it is worth stating plainly: the conflict resolution for concurrent edits in a JSON file in a git repository is the hard part, and the README documents the transport, not the merge.

Offline caching and resumable transfer also imply local persistence in the browser, so the PWA keeps a working copy on the device. Which means the app has to reconcile a local copy that may have diverged while offline with a repository that may have moved on. Again, the README says the capability exists and does not say how conflicts resolve.

The sync endpoint is abstracted, and the README says future versions will support self-hosted servers, network drives such as Dropbox and OneDrive, and local offline ledgers. WebDAV sync is already listed as done, so at least one alternative to GitHub is available today.

## AI features run on an OpenAI-compatible API you configure

The AI features are the part that has grown fastest. A long press on the record button starts voice entry, and the AI parses the amount, the category and the note from what you said.

Beyond that, once you configure an OpenAI-compatible API, the app supports conversational analysis of your bills, budget suggestions and an annual summary, and it can predict the category of a transaction from your history.

The keyword in that paragraph is that you configure it yourself. Cent does not ship a model or a hosted AI service for this, it talks to an endpoint you supply, which means the AI features are opt-in and cost-shaped by whichever provider you point at. That is a sensible design for a project that describes itself as free, since the expensive part is optional and yours to pay for.

The README also mentions intelligent import of WeChat and Alipay bills, with the option to create custom import schemes with the help of AI, and natural language recognition among the quick actions, alongside clipboard-based entry, iOS shortcuts and batch editing.

The rest of the feature set is a normal personal finance app: secondary categories and a custom tag system with groups and single or multi select, multi-dimension filtering and trend analysis, custom analysis views, budget management with progress monitoring, a map view of spending footprints with AMap support, more than thirty international currencies with custom currencies and automatic exchange rate conversion, periodic entries for subscriptions and automatic renewals, dark mode, custom CSS and keyboard customisation.

## Self-hosting means giving up one-click login

There are two ways to use Cent. The first is the hosted version, where you open the site, sign in with GitHub, create a book, and a repository is created for you.

The second is self-hosting, and the README is unusually direct about what that costs you. You fork the repository, deploy to Cloudflare Pages or any static hosting platform, and then at the login screen you manually enter a GitHub token. All books and data are stored in your own GitHub repositories.

The reason is security. The README states that for security reasons the self-hosted route cannot use one-click GitHub or Gitee login, and that you need to generate a token with repository read and write permission yourself in the platform's settings and paste it into the app.

That is a real trade. A token with repo read and write scope, entered into a page in a browser, is a credential with a wide blast radius if the page is compromised, the browser is compromised, or the hosted site is not the one you audited. The hosted version avoids that by delegating authentication to a service that only serves trusted domains.

That service is described in the README: Cent uses Cloudflare Workers to run an online authentication service that serves only trusted domains, and it points to the separate `cent-github-backend` project as a reference for creating your own backend and registering your own OAuth app on the relevant platform.

So the self-host path is fully possible, but it puts the OAuth plumbing and the token handling on you, and a static host cannot do the OAuth callback for you without the Workers service.

## A pnpm monorepo with a Biome and commitlint workflow

The repository is a pnpm monorepo. The root `package.json` is named `cent-monorepo`, marked private, with version 2.0, module type and pnpm 10.15.1 as the declared package manager.

The scripts are all filtered through the workspace. `dev`, `build`, `preview` and `analyze` run against the `cent` package, and there are separate `dev:chaty` and `dev:zen` scripts for two other workspace packages, `@glink25/chaty` and `@glink25/zen`, with matching build scripts. The `lint` script runs across all packages recursively, and `prepare` installs the husky hooks.

The tooling is modern and opinionated. Biome at 2.2.2 handles linting and formatting in one tool, configured by a `biome.json` at the root. Commitlint with the conventional config validates commit messages, and husky wires it into the commit hook. The root has a `biome.json`, a `commitlint.config.cjs` and a `.husky/` directory, plus `apps/` and `packages/` directories and a `pnpm-workspace.yaml`.

The contributing section gives the local workflow as a short command list, with a clone, an install with pnpm, a dev script, and a lint script for format checking.

```bash
git clone https://github.com/glink25/Cent.git
pnpm install
pnpm dev
pnpm lint
```

The project is developed by a single maintainer, and the README says so directly in the funding section, noting that Cent is currently supported by one person and that donations go toward maintenance and continued development. A QQ group and a documentation site under the maintainer's GitHub pages are also linked.

## The roadmap says the test suite is still being built

The development plan section separates work into three buckets, and the middle one is the one that matters for an adopter.

Completed items include the incremental sync core implementation, the multi-user collaborative book, the AI assistant, voice entry, multi-currency support with exchange rate management, map-based spending visualisation with AMap, periodic entries, intelligent import of Alipay and WeChat bills, the upgraded tag system, WebDAV sync support, shortcut integration and batch editing.

In progress are the automated test system and additional sync endpoints for Dropbox and OneDrive.

Planned are data report export to PDF and Excel, and further intelligent features.

So the feature set is broad and the automated test suite is not there yet. For a project whose data lives in a user's GitHub repository and whose correctness depends on a custom diff and merge, that ordering is worth thinking about. A bug in the sync logic can corrupt a shared ledger, and there are no automated tests behind that code path to catch a regression.

There are no GitHub releases for the repository, so there is no version history to consult. The last push was on 2026-09-22, the repository is not archived, and the manifest version is 2.0.

The contribution guide is in the repository at `docs/contributing/zh.md`.

## Where Cent is the wrong choice

The first wrong case is a business. The licence is Creative Commons Attribution-NonCommercial-ShareAlike 4.0, which the README summarises as allowing sharing, adaptation and republication with attribution, requiring derivative works to use the same licence, and prohibiting commercial use. A company or a freelancer using this for client work is outside the grant.

The second is anyone whose records should not sit in a git host. Every balance change is a commit in a repository, so the full history of who spent what, and when, is a permanent, browsable artefact on a third-party service. For a personal expense tracker that is often fine and occasionally delightful. For a business ledger, or for anything with a duty of confidentiality, it is a decision that needs a lawyer rather than a README.

The third is a deployment where you cannot paste a token into a browser page. The self-hosted route needs a repository read and write token entered manually, and the hosted route depends on the maintainer's Cloudflare Workers authentication service being reachable and registered for the domain you are on. A locked-down corporate environment with strict credential policies rules both out.

The fourth is a group that needs fine-grained permissions. Collaboration is GitHub Collaborator access, which means repository write access, which means the whole ledger.

The fifth is a user who wants a server-side product. There is no backend to query, no API to integrate with, and no way to run a report across books other than the app's own export, which is still on the planning list.

## Conclusion

Cent suits a group of friends, a family or a small club that wants a shared expense ledger with no server to run and no subscription to pay, and that is comfortable letting GitHub hold financial records and commit history. It does not suit a business, because the CC BY-NC-SA 4.0 licence forbids commercial use, and it does not suit anyone who cannot put a repository-scoped token into a browser. Before deploying it, read the `LICENSE` file in the repository root, decide whether your records belong on GitHub at all given that every change is a commit, and if you self-host, generate a token with repository read and write scope and accept that the one-click OAuth login is unavailable.

## FAQ

### Where does Cent store its data?

Each ledger is a GitHub or Gitee repository, and the data is stored as JSON inside it, which also gives history rollback. Books are identified by repository name, so multiple ledgers are supported.

### Does Cent need a server?

It is a pure front end PWA and depends on no backend service apart from GitHub or Gitee OAuth login. The hosted version at cent.linkai.work uses a Cloudflare Workers authentication service for trusted domains.

### How do I self-host Cent?

Fork the repository, deploy it to Cloudflare Pages or any static host, and enter a GitHub token manually on the login screen. The self-hosted route cannot use one-click OAuth login for security reasons, so you generate a token with repository read and write permission yourself.

### Can I use Cent for commercial purposes?

No. The project uses Creative Commons Attribution-NonCommercial-ShareAlike 4.0, which the README summarises as prohibiting commercial use while requiring attribution and the same licence for derivative works.

### What AI features does Cent support?

Voice entry that parses the amount, category and note, conversational analysis of bills, budget suggestions and an annual summary, category prediction from history, and AI-assisted creation of custom import schemes, all against an OpenAI-compatible API you configure.

## Sources

- [glink25/Cent on GitHub](https://github.com/glink25/Cent)
- [Issues](https://github.com/glink25/Cent/issues)
- [Project website](https://cent.linkai.work/)
- [README](https://github.com/glink25/Cent/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/glink25-cent