price Tracks LLM Inference Costs

price is a public GitHub project by tokencanopy that records LLM inference prices across many providers on a schedule. It deals with a very ordinary pain: you run out of quota in Claude Code, Anthropic’s coding agent, or OpenAI Codex, OpenAI’s coding agent, and suddenly need to know where the same open model is cheapest to run. The takeaway is simple: use price as a price-history receipt, not as an automatic router. It is especially handy around Codex CLI workflows where model choice, quota, and verification cost all show up in the same engineering day.

LLM inference price history is a time-stamped record of what providers charged to run models at earlier points in time. That sounds boring until yesterday’s number matters and the provider page only shows today’s price.

See what the project actually records

The repo’s idea is small and good: scrape public LLM inference pricing every six hours, commit the result, and let git act as the time-series database. As of September 3, 2026, its README reported 13,390 price points, 886 models, 73 platforms, and history beginning September 2, 2026.

That makes price less like a polished SaaS dashboard and more like a public ledger. The value is not the UI. The value is that each snapshot can be diffed, reviewed, subscribed to, and forked.

The author’s motivating case was very practical. When quota ran out in coding tools, they wanted to compare providers for models like DeepSeek and Kimi K2-style options, then track whether the apparent deal stayed a deal. Their early read was that OpenRouter was still often the practical default, but the repo is useful precisely because that can change.

The trap is treating a scraped public price as the full cost of running an agent. Price per token is only one line item. Latency, rate limits, context caching, tool-call behavior, failed runs, and support for the exact model variant can matter more than a tiny nominal discount.

Notice the trick: git is the database

The clever part is not a new pricing formula. It is the decision to make the history boring and inspectable.

A GitHub Actions-style loop can fetch provider pages or APIs, normalize the data, and commit the snapshot. Once the data lands in git, you get diffs, blame, forks, Atom feeds, and pull requests for free. That is a very developer-native shape.

This is why the project caught attention from people building with agents. Pricing pages are optimized for conversion. Git history is optimized for remembering what changed.

A real workflow might look like this: you keep a weekly note for your Codex runs, see that one open-weight model is served by five providers, and check price before moving a batch of test-generation prompts to another endpoint. You are not asking price to pick the route. You are asking it to keep the receipt honest.

The trap is assuming “same weights” means “same product.” The README calls out wide spreads for open models, but the reasons can include hardware, throughput, precision, margin, and service behavior. A faster expensive endpoint can still be cheaper for an agent run if it avoids retries or finishes before a developer gives up.

Use it when quota shapes the work

price is worth trying when model cost or quota affects the way you run coding agents. If you are using the Codex CLI for exploratory refactors, test generation, or large review passes, a cheap route can make the difference between “run one careful pass” and “run three smaller passes with verification.”

The better use is pre-flight planning. Before a long Codex session, check whether the model/provider pair you plan to use has moved, whether an open model has a much cheaper host, and whether that host supports the capabilities your workflow needs.

Here is the kind of boundary note I would put in a repo that uses Codex with alternate inference endpoints:

# AGENTS.md

## Model routing and cost checks
- Before long-running Codex CLI tasks, check current and historical inference pricing for the selected model/provider pair.
- Do not switch providers only because token price is lower.
- Preserve the repo’s verification loop: run tests, type checks, and lint before summarizing work.
- If using an MCP server for provider metadata, keep it read-only unless the task explicitly requires writes.
- In handoff notes, record the model/provider used when cost, latency, or quota affected the result.

That instruction is deliberately modest. It helps the codex agent remember the decision boundary without pretending pricing data is a substitute for engineering judgment.

The trap is wiring live price data into every agent decision too early. A route that changes under an agent can make debugging miserable. Start with human-visible checks and written handoffs. Automate only after you know which decisions are repetitive and safe.

For a deeper Codex CLI workflow pattern, see the related training topic. If you are thinking about agent environments more broadly, the same “know what is bundled before you trust the run” habit also shows up in Why ChatGPT/Codex Bundles LibreOffice.

Try price safely

Use this as a quick experiment, not a procurement process.

A safe first pass:

• Pick one recurring Codex CLI task, such as test generation for a large package.
• Write down the current model, provider, context size, and normal verification command.
• Check price for that model/provider and one plausible fallback.
• Run the same task shape twice on a small branch, not on a production hotfix.
• Compare total tokens, wall-clock time, retries, test results, and review effort.
• Keep the cheaper route only if the whole loop is cheaper, not just the token line.

For example, a repo might use this verification loop after a Codex-generated change:

npm test -- --runInBand
npm run typecheck
npm run lint

If the cheaper endpoint saves 40% on token price but causes one extra failed test-repair loop, the saving may disappear. That is the part a dashboard cannot know for you.

Common questions

• Is price a router for LLM inference?

  No. price is a public price-history dataset, not an inference gateway or routing layer. The repo records provider and model pricing over time; your application still decides which endpoint to call, how to evaluate quality, and what fallback behavior is safe.

• How often does price update?

  The project says it refreshes every six hours. As of September 3, 2026, the README showed two snapshots and history since September 2, so the dataset was young but already structured around repeatable time-based collection.

• Why did Codex users care about this Show HN project?

  Codex users cared because quota and inference cost affect real coding-agent workflows. When a long OpenAI Codex or Codex CLI session hits limits, developers often need a credible fallback model/provider, and historical pricing helps avoid trusting only a provider’s current marketing page.

• Can I use it to compare the same open model across providers?

  Yes, that is one of the best uses. The README highlights that open-weight models can appear on many platforms at very different prices, but you still need to compare precision, latency, throughput, limits, and reliability before calling two endpoints equivalent.

• Is scraped pricing reliable enough for production decisions?

  It is reliable enough for investigation, not enough by itself for production commitments. Public prices can lag, be normalized differently, omit discounts, or miss private terms, so treat price as a starting receipt and confirm anything material with the provider you will actually use.

Best ways to use this research

• Best for: Developers who already run coding agents and need a clearer fallback plan when quota, price, or provider availability interrupts the work.
• Best first artifact: Add a short AGENTS.md note that says when to check inference price history and when not to switch providers automatically.
• Best comparison angle: Compare total verified task cost, not listed token price. Include retries, latency, failed tool calls, and the human review loop.
• Best Codex fit: Use price before long Codex CLI sessions where the route is flexible, the task is repeatable, and the verification command is already clear.

Further reading

• OpenAI Developers — Codex CLI docs
• OpenAI Developers — Codex CLI
• price — source

Keep the receipt

Try price on one repeatable agent task before you need it in a quota crunch. If the cheaper route still passes the same verification loop with fewer total retries, write that down where your next Codex run can see it.

One methodology lens

One useful way to read this through our methodology is the Plan step: delegate first-pass decomposition and dependency mapping, review the sequencing and assumptions, and keep ownership of scope and priorities. If that split is still fuzzy, the workflow usually is too.