acc0 CLI

One static binary for your books: push receipts and invoices from the terminal, list the AI’s reconciliation proposals, export your ledger as CSV. Built as much for your AI agent as for you — same commands, machine-readable output in a pipe.

Install

curl -fsSL https://acc0.dev/install.sh | sh
acc0 --version

No runtime, no package manager. Installs to ~/.local/bin; set ACC0_INSTALL_DIR to change that. macOS, Linux, and Windows.

Authenticate with an API key

Everything except listenauthenticates with an API key — create one in the app under Settings → API keys (org owners only). It’s shown once, at creation, so copy it then.

acc0 login              # prompts for the key, verifies it, saves it
export ACC0_TOKEN=...   # or: fully headless, no login step, no config file

Keys are read-only by default — choose read & write when the key needs to push documents. Even a read & write key can never approve anything.

Lookup order, first match wins: --token flag, then ACC0_TOKEN, then ~/.config/acc0/config.json (written by login).

Commands

acc0 push <file>... [--account <id-or-slug>] [--json]   # upload receipts, invoices, statements
acc0 incoming [--json] [--limit <n>] [--all] [--cursor <createdAt,id>]  # proposals waiting for your review
acc0 status <documentId> [--json]               # poll one pushed document's pipeline status
acc0 jobs [--failed] [--state <s>] [--json]     # the org's pipeline, newest first
acc0 proposal <id> [--json]                     # full detail for one proposal
acc0 export --account <id-or-slug> [--period all|month|quarter|fy] > ledger.csv
acc0 comment <proposalId> <message>             # leave a triage note on a proposal
acc0 listen [--port 4242] [--secret <secret>]   # local webhook receiver
acc0 docs [--agents]                            # print the machine-oriented reference
acc0 completion bash|zsh|fish
acc0 help [command]

acc0 push <file>... [--account <id-or-slug>] [--json]: Send acc your paperwork. Each receipt, invoice, or statement you push starts the extraction pipeline and prints its documentId. Pushing the same file twice is safe: you get the same id back, not a duplicate. --account files the documents under one of your accounts, by id or by the slug in its URL (the account at /a/everyday has the slug everyday). If the organisation has no credit, the push fails outright with 402(nothing is stored) — add credit and try again. One credit covers one document from classification through to its proposals. If we can’t work out what a document is and hand it back for you to retry or delete, that costs you nothing — you pay when the extraction lands.
acc0 status <documentId> [--json]: Just pushed something? This shows where it is in the pipeline (extracting, reconciling, proposed, or needs your attention) plus any error. Handy in a script right after push, no webhook setup needed.
acc0 jobs [--failed] [--state <s>] [--json]: The same view for everything at once: every document your org has sent in, newest first. --failed narrows to the ones that broke, which makes this a one-liner for a cron job that tells you when something needs a look.
acc0 incoming [--json] [--limit <n>] [--all] [--cursor <createdAt,id>]: Your review queue: the proposals the AI has prepared and is waiting for you to approve in the app. Shows 50 at a time; raise --limit (up to 200), continue where you left off with --cursor, or print the whole queue with --all (which can’t combine with --cursor or --json).
acc0 proposal <id> [--json]: Everything about one proposal before you approve it: the matched bank lines, the source document, category, the AI’s reasoning, and any discussion. Use an id from an incoming row. Once a proposal is approved or rejected it leaves the queue, so it returns a 404 here.
acc0 comment <proposalId> <message>: Leave a note on a proposal for whoever reviews it. It appears in the app’s Incoming thread with an API badge, so it never reads as the AI or as the reviewer. Notes can’t change a proposal’s state, and commenting fails once a proposal is approved or discarded.
acc0 export --account <id-or-slug> [--period all|month|quarter|fy] > ledger.csv: Your ledger as CSV, straight to stdout: pipe it into a file, a spreadsheet, or a script. Pick the account (same id-or-slug as push) and optionally a period: this month, this quarter, this financial year, or everything.
acc0 listen [--port 4242] [--secret <secret>]: Trying out webhooks? This runs a receiver on your machine and prints each delivery as it lands. See Local webhook testing below for the tunnel setup and signature checks.
acc0 docs [--agents]: The whole CLI reference, printed from the binary itself: ideal offline, or for handing to an AI agent that should learn the tool without fetching anything. --agents prints a short block you can paste straight into your AGENTS.md or agent config.
acc0 completion bash|zsh|fish · acc0 help [command] · acc0 --version: Tab completion for bash, zsh, or fish; help for any command; --versionfor what you’re running.

Using it from an AI agent

Set ACC0_TOKENand hand your agent the binary. It never prompts when stdin isn’t a terminal, so a scripted call either succeeds or fails; it never hangs.

Streams: Data goes to stdout; status, progress, and errors go to stderr. stdout of every command is safe to redirect or parse.
Machine output: Piped incoming is TSV, in a fixed column order, with no header, and new columns are only ever appended: id, date, amountMinor, currency, description, confidence. --json prints the raw API response verbatim.
Money: Amounts are integer minor units (amountMinor), never floats, in every machine-readable output. Formatted decimal strings appear only in the human-readable table.
Exit codes: 0 on success, 1 on any failure (network, auth, server, file), 2 on a usage error such as bad flags or invalid combinations.
Errors: When stderr isn’t a terminal, an error prints as one line of JSON, {"error": "..."}, so an agent parses failures the same way it parses successes. On a real terminal the same message prints as plain text.
Stability: Breaking any of these guarantees bumps the CLI’s major version; acc0 --version tells you what you have.

Retries are safe: re-pushing identical bytes returns the same documentId instead of creating a duplicate — a network timeout after the server processed a push never costs you a second document or a second parse.

After a push, poll acc0 status <documentId> — no webhook tunnel needed. acc0 jobs [--failed] gives the same view across the whole org, for a cron script watching for trouble.

acc0 docs prints this whole contract from the binary — --agents emits a paste-ready block for your agent config.

Cross-checked a proposal against evidence you hold? Run acc0 comment <proposalId> "<note>" to leave your findings on the proposal — the human sees them in Incoming.

Local webhook testing

acc0 listen prints webhook deliveries on your machine. No API key needed.

acc won’t deliver to localhost or private addresses, so put a tunnel (cloudflared, ngrok) in front: register the tunnel URL as your webhook, run acc0 listen, and watch deliveries land. With --secret, each delivery’s signature is checked and labeled VERIFIED or INVALID SIGNATURE. Payload shapes and signature details: see the webhook docs.

Approving proposals

There’s no approve command, on purpose. The CLI can propose and read; booking anything stays a human decision, made in the app.