中文 English

Subscribed to 7 AI Coding Plans? I Built a Dashboard So I Don't Have to Open 7 Tabs Every Day

Published: 2026-07-25 · Views --
AI Coding Coding Plan Dashboard Open Source Docker Developer Tools Quota Monitoring

TL;DR

If you subscribe to several AI coding plans at once — Codex, MiniMax, Volcengine, Kimi Code, LongCat, Qianwen AI, Google AI — you already know the daily ritual: log into seven different websites, fight through seven different login systems, and dig around seven different UIs just to answer one simple question: how much quota do I have left? I got tired of it, so I open-sourced a self-hosted quota dashboard called coding-plan-dashboard. One docker compose up -d later, every plan's remaining percentage, reset countdown, and multi-account status is aggregated on a single dark, glanceable page. This post was written and screenshotted on July 25, 2026.

Illustration: quota data from seven AI coding platforms converging into a single dashboard

Why this exists

Between late 2025 and 2026, AI coding tools exploded. OpenAI shipped Codex, Anthropic's Claude Code went mainstream, and a wave of monthly coding plans arrived — Volcengine, Kimi Code, MiniMax, LongCat, and Qianwen AI all launched subscription tiers aimed squarely at developers. Google's Gemini line joined the fray too, reachable through tools like Antigravity.

For developers like me — the kind who route each task to whichever model is cheapest, or whichever plan still has quota left this week — multi-platform subscriptions are basically unavoidable. The problem is that every single vendor answers the question "how much do I have left?" in a completely different way:

It's like holding monthly memberships at seven different gyms and being forced to open seven different apps every morning just to figure out which one you can still walk into today. None of it is broken — it's just endlessly, needlessly annoying.

Illustration: a developer surrounded by seven different quota pages, switching tabs all day

What it looks like

Screenshots first. Here is the dashboard actually running on my home network:

Screenshot: dashboard header showing account count, total limit, total usage, and last refresh time

The top of the page carries four summary cards: account count (I currently have 9 accounts imported), total limit (800 requests), total usage (470.022 requests), and the time of the most recent data refresh. In the top-right corner there's a lock icon — indicating the data is only reachable on the local network — plus a "Refresh available data" button.

Scroll down, and each platform gets its own card, laid out in two columns:

Screenshot: Codex and MiniMax quota cards with usage percentages, progress bars, and reset countdowns

Take the Codex card as an example: it shows that I'm currently going through a NewAPI proxy channel, that 2 reset cards are available, and that the nearest reset expires on August 12, 2026. Weekly quota sits at 90.0% used, 10.0% remaining. In the card's corner a live countdown ticks away — "resets in 6 days, 14 hours, 51 minutes, 24 seconds." The MiniMax card shows its 5-hour window at 92.0% used, with a gradient progress bar visualizing the burn.

The "see everything at once" feeling is best described this way: it's like merging seven gym apps into one unified health panel. You no longer need to remember seven passwords or bounce between seven interfaces. One page, everything legible at a glance.

Screenshot: Volcengine CodingPlan and AgentPlan cards across multiple accounts

The Volcengine section is even more representative — I've imported CodingPlan and AgentPlan entries from several accounts, and each account renders as its own sub-card with its own usage percentage and reset schedule. Think of a family holding several gym cards: the panel shows each card's status separately, nothing gets blurred together.

Screenshot: Kimi Code and LongCat quota cards

The Kimi Code and LongCat cards follow the same visual language: percentage number, colored progress bar, reset countdown. LongCat shows 28.0% used, while my multiple Kimi Code accounts show 5.7%, 10.2%, and 23.6% respectively — and this is exactly where multi-account support earns its keep. When one account is running dry, a single glance tells you which account to switch to next.

Screenshot: Qianwen AI and Google AI quota cards

Qianwen AI's TokenPlan and Google AI (Gemini 3.5 Flash) each get their own card as well. Google AI shows 0.0% usage here, because its OAuth refresh mechanism is a bit special — you need to configure OAuth client credentials via environment variables before the server can pull its data successfully.

How it works under the hood

The whole architecture fits in one sentence: you paste a curl command into the browser, the server parses it and re-issues the request with Python, caches the result as JSON, and the frontend reads that JSON and renders it as cards.

Architecture diagram: data flowing from the AI platform APIs through server.py to the browser dashboard

Think of it as a package-pickup concierge service. You hand the concierge (server.py) the pickup codes from seven courier companies — the cookies, tokens, and headers buried inside your curl commands. Every refresh cycle the concierge does the rounds, checks each courier's status (quota percentage, reset time), and writes everything onto a single sheet (snapshot.json). All you ever do is read the sheet.

The concrete flow:

  1. Import the curl. At the bottom of the page there's a text box where you paste the raw curl command copied from your browser's developer tools. The server auto-detects which platform it belongs to based on the URL — for example, a URL containing chatgpt.com/backend-api/wham/usage is classified as Codex, one containing www.minimaxi.com as MiniMax, and so on.
  2. The server replays the request. server.py never shells out to run curl. Instead it parses the headers, cookies, and request body from the curl command using a Python HTTPS library and re-issues the request itself. That means even if your curl carries --proxy or --insecure flags, the server handles them correctly.
  3. Results are persisted. Every refresh writes the API responses to snapshot.json and results.json. After a container restart, the page first paints the cached snapshot, then silently refreshes to fresh data in the background — no "white screen while loading" experience.
  4. The frontend renders. index.html is a fully self-contained single-file frontend with zero external CDN dependencies. Each platform card shows the usage percentage (to one decimal place), a colored progress bar, and a live countdown.

Multi-account and special-platform support

The dashboard supports importing multiple accounts for the same platform. Each account gets its own label, and you can edit it, delete it (with a confirmation step), and drag it to reorder. This is enormously practical for the "switch to another account when one runs low" workflow — no more swapping cookies around in your browser; every account's status sits side by side on the board.

Volcengine additionally supports a "curl-free" import path: fill in an Access Key and Secret Key directly on the card, and the server calls the GetCodingPlanUsage or GetAgentPlanAFPUsage API using an HMAC-SHA256 V4 signature. This is far more stable than copying curl out of a browser every few days, because AK/SK credentials don't expire the way browser cookies do.

Codex also supports a NewAPI proxy channel: if your Codex traffic is routed through NewAPI, you can import the NewAPI /api/channel/{channelId}/codex/usage URL instead, and the server will automatically skip the official endpoint — avoiding a stream of 401 errors polluting your board.

Screenshot: the curl import area at the bottom of the page, plus the Volcengine AK/SK configuration area

Deployment takes one Docker command

The entire project is just three core files: index.html (frontend), server.py (backend), and docker-compose.yml (container orchestration). Deployment goes like this:

# 1. Clone the repository
git clone https://github.com/margrop/coding-plan-dashboard.git
# 2. Enter the directory
cd coding-plan-dashboard
# 3. Create the data directory
mkdir -p data && chmod 700 data
# 4. Start the container
docker compose up -d
# 5. Open http://your-server-ip:8080 in your browser

That's all five steps. It listens on port 8080 by default; if that's taken, just change the PORT environment variable in docker-compose.yml. The container's data is mounted to a data/ directory on the host, containing four JSON files:

If you manage Docker with Portainer, you can equally well create a Stack in Portainer, paste in the contents of docker-compose.yml, and hit Deploy. The only prerequisite is that index.html, server.py, and an empty data/ directory already exist on the host machine.

One-click deploy scripts for three platforms

The three scripts below do exactly the same thing: clone the repo from GitHub, create the data directory, and start the Docker container. The scripts upload no configuration, call no third-party services, and depend on no external configuration platform; they only require that Docker Engine and Docker Compose v2 are already installed on your machine.

Running it yourself: download the matching script and run it in your terminal. The script creates a coding-plan-dashboard folder in the current user's home directory and starts the container there.

Letting an agent do it: send the prompt below to your AI coding agent (Claude Code, Kimi Code, Cursor, etc.) and it will download and execute the script automatically:

Please clone the repository from https://github.com/margrop/coding-plan-dashboard,
create a coding-plan-dashboard deployment directory under the current user's home directory,
run docker compose up -d to start the container,
then tell me the access URL.

What about security?

This is the question I get asked most often, and it's the part I cared about most while building the project.

The server never shells out to run curl. Imported curl commands are parsed in Python and replayed with a standard HTTPS library. There is no command-injection surface.

Domain allowlist. The server only sends requests to chatgpt.com, www.minimaxi.com, console.volcengine.com, www.kimi.com, longcat.chat, cs-data.qianwenai.com, plus any NewAPI address you configure manually. It will never issue an HTTPS request to an arbitrary address.

Credentials stay local. requests.json and credentials.json live in the host's data/ directory with permissions set to 700 (owner read/write only). Don't commit them to a Git repository, and don't upload backup files to the public internet.

Keep it on your LAN. Port 8080 ships with no authentication mechanism whatsoever, so make sure only trusted devices can reach it. If you genuinely need public exposure, put your own reverse proxy and authentication layer in front of it.

An analogy: this dashboard is like a smart-home control panel hanging in your living room. It shows you the status of every room in the house — but the panel itself has no lock. So it belongs inside your home (the LAN), not bolted to the front gate of the apartment complex (the public internet).

How it compares to similar tools

The community already has a few projects in this space. There's ai-quota, a macOS menu-bar tool that shows Codex and Claude Code usage right in the status bar; and there are Claude Code skills like AI Usage Monitor that surface multi-platform quotas inside the terminal. Each has its strengths:

coding-plan-dashboard occupies a different niche: it's a platform-agnostic, fully aggregated, self-hosted web dashboard. It doesn't care about your operating system (anything with a browser works), it doesn't care which AI coding tool you use (it monitors quotas, not tools), it covers seven platforms today, and it's easy to extend to more. If you only use one or two platforms, the lightweight tools above will probably feel snappier. But if you, like me, cast a wide net, a unified board removes a huge amount of daily switching cost.

FAQ

Q: My curl contains tokens. Is that safe?

The tokens are stored in plaintext in data/requests.json — roughly the same security level as the tokens already sitting in your browser cookies. The server never sends them anywhere outside the domain allowlist. That said, make sure the data/ directory has 700 permissions, and never upload backup files to a public location.

Q: Do I lose data when the container restarts?

No. Every imported curl command and every quota snapshot lives in the host-mounted data/ directory. After a restart, the page first shows the last cached snapshot and then refreshes silently in the background.

Q: Which platforms are supported, and can I extend it?

Currently: Codex, MiniMax, Volcengine (CodingPlan + AgentPlan), Kimi Code, LongCat, Qianwen AI, and Google AI (Gemini 3.5 Flash / Antigravity). Adding a platform means adding a URL recognition rule and parsing logic to server.py, plus a matching card template in index.html. The project's AGENTS.md contains a detailed development guide.

Q: Why is Volcengine's AK/SK mode better than curl?

Browser cookies expire, and the tokens inside a curl command go stale just the same. AK/SK pairs are long-lived credentials that never expire unless you rotate them manually. On top of that, the AK/SK path uses HMAC-SHA256 V4 signing and doesn't depend on any browser login state, which makes it far more stable over time.

Q: Can I deploy this to the public internet?

Technically yes, but strongly not recommended. The dashboard ships with no built-in authentication — anyone who reaches the page can see your quota information (they won't see raw tokens, but they will see usage numbers and account labels). If you really must expose it publicly, put Nginx or Caddy in front as a reverse proxy and enable Basic Auth or OAuth.

The project is fully open source under the MIT license:

If this project saves you some tab-switching pain, a Star is the best encouragement there is. And if you're using a platform I haven't covered yet, file an issue or send a PR — I'm happy to add it.

Screenshot: the complete dashboard page, dark theme, every platform card visible at once

One last thought: AI coding plans keep multiplying, and every vendor is racing on price, on models, on quota sizes. But as users, what we actually need isn't "one more plan" — it's knowing, clearly, exactly how much is left on each one. This dashboard solves that last-mile aggregation problem. I hope it helps you too.

本文阅读量 --