statlyte — live LLM pricing
Live LLM pricing, context windows and model ids, read from each vendor's own page every 3 hours.
Open source Open in the app JSON README (API)
About
Live LLM pricing, context windows and model ids, read from each vendor's own page every 3 hours.
Details
- Kind
- MCP servers
- Topic
- AI, RAG & memory
- Publisher
- richardwilkinson9
- Origin
- official
- Category
- ferramentas
- Transport
- local
- Version
- 0.1.1
- Last push
- 2026-08-14T07:54:33Z
- Repository state
- ativo
- Language
- JavaScript
- License
- MIT
- Added
- 2026-08-29 04:01:18
- Updated
- 2026-08-29 04:01:18
- Origin id
io.github.richardwilkinson9/statlyte
README
# statlyte
**Live pricing, context windows and identifiers for every major LLM API — so you can stop hardcoding a model table that goes stale.**
Every app that touches an LLM ends up with something like this pasted into it:
```js
const PRICES = {
'gpt-4o': { input: 2.5, output: 10 },
'claude-3-5-sonnet': { input: 3, output: 15 },
// …written once, wrong within a month
};
```
Then a model is retired, a new one lands, an introductory rate expires, and your cost
dashboard is quietly lying to you. This package fetches the current numbers instead.
- **159 models across 13 providers** — Anthropic, OpenAI, Google, xAI, DeepSeek, Mistral, Together AI, Voyage AI, Groq, Cohere, Fireworks AI, Deepgram, AssemblyAI
- Read from each vendor's **own published pricing page**, every three hours, with the source URL recorded
- **Zero dependencies.** Node, Bun, Deno, Cloudflare Workers, browser
- Bundled snapshot fallback, so a flaky network never throws in your request path
- **MIT.** The data is free and the API needs no key
```bash
npm i statlyte
```
## Use it
```js
import { getModel, costOf, rankByCost, scheduledChanges } from 'statlyte';
// What does this actually cost me?
await costOf('claude-sonnet-5', { input: 12_000, output: 800 });
// => 0.032
// Look up by statlyte id or the vendor's own API id
const m = await getModel('gpt-5-mini');
m.contextWindow; // 400000
m.prices.input; // 0.25 (USD per million tokens)
m.prices.cache_read; // 0.025
// Cheapest model for a real monthly workload
const ranked = await rankByCost({ inputPerMonth: 620e6, outputPerMonth: 210e6 });
ranked[0].name; // cheapest first
ranked[0].monthlyCost; // USD/month
// Price rises vendors have already announced
await scheduledChanges();
// [{ name: 'Claude Sonnet 5', effectiveOn: '2026-09-01',
// from: { input: 2, output: 10 }, to: { input: 3, output: 15 },
// reason: 'Introductory pricing ends' }]
```
Everything is cached in-process for six hours. Pass `{ offline: true }` to any call to
use only the bundled snapshot and never touch the network.
Audio/transcription models (Deepgram, OpenAI Whisper/TTS) aren't priced per token — they carry
`m.nonTokenPrice` (`{ unit: 'per_minute' | 'per_million_characters', amount }`) instead, and
`m.prices` is `{}`. `costOf()` throws a clear error rather than silently returning 0 if you call
it on one of these; check `m.nonTokenPrice` first, or filter on `m.prices.input != null`.
## Fail your build when a price is about to change
The genuinely useful trick. `scheduledChanges()` returns increases vendors have announced
but not yet applied — so you can find out at build time rather than on the invoice:
```js
// scripts/check-model-costs.mjs
import { scheduledChanges } from 'statlyte';
const MODELS_WE_USE = ['anthropic/claude-sonnet-5', 'openai/gpt-5-mini'];
const soon = (await scheduledChanges())
.filter((c) => MODELS_WE_USE.includes(c.id))
.filter((c) => new Date(c.effectiveOn) - Date.now() < 60 * 86400_000);
if (soon.length) {
console.error('Price change coming:');
for (const c of soon) {
console.error(` ${c.name} on ${c.effectiveOn}: ` +
`in $${c.from.input}→$${c.to.input}, out $${c.from.output}→$${c.to.output} per MTok`);
}
process.exit(1);
}
```
## MCP server
An assistant's training data goes stale on prices within weeks, and a guessed number is
worse than no number. This gives your agent the current figures:
```bash
claude mcp add statlyte -- npx -y statlyte
```
<details>
<summary>Other MCP clients</summary>
```json
{
"mcpServers": {
"statlyte": {
"command": "npx",
"args": ["-y", "statlyte"]
}
}
}
```
</details>
Tools: `list_models`, `get_model_pricing`, `estimate_cost`, `cheapest_for_workload`,
`scheduled_price_changes`.
Also listed in the [official MCP Registry](https://registry.modelcontextprotocol.io/) as
`io.github.richardwilkinson9/statlyte`.
## Or just take the JSON
No install, no key, CORS open:
```
https://statlyte.com/api/v1/models
https://statlyte.com/api/v1/models/anthropic/claude-opus-5
https://statlyte.com/api/v1/changes
```
The raw dataset also lives in this repo as [`models.json`](models.json) and
[`changes.json`](changes.json), updated by commit — so you can diff it, pin it, or vendor it.
## Where the numbers come from
A job re-reads each provider's published pricing page every three hours. When a figure
differs from the last one on file it writes a new observation with a timestamp and the URL
it was read from. Nothing is inferred and nothing is estimated: **if a price isn't
published, it isn't listed.**
Two honest caveats:
1. **These are list prices.** Negotiated, enterprise, regional and committed-spend rates
differ, sometimes a lot. Confirm with the vendor before making a commercial decision.
2. **Cheaper is not the same as substitutable.** This records what models cost, not what
they can do. `rankByCost` will happily tell you an 8B model is cheaper than a frontier
one. That is arithmetic, not advice.
Found a figure that disagrees with a vendor's page? The vendor is right and we're wrong —
[open an issue](https://github.com/richardwilkinson9/statlyte-data/issues) and it gets fixed
on the next run.
## The rest of it
[statlyte.com](https://statlyte.com) has the human-facing side: a change log, a
[calculator](https://statlyte.com/calculator) that puts two models head to head at your own
volume, and a [calendar](https://statlyte.com/calendar) of announced changes. Free, no
account.
MIT licensed. Attribution appreciated, not required.