AI model prices move constantly. A new model drops, an old one gets cheaper, a provider revises their rate card. When a platform resells access to dozens of models, updating prices by hand is slow and error-prone — and one missed row means you’re either selling at a loss or overcharging customers without knowing it.
CoreSynth now runs an automated pricing sync that handles this properly.
What the sync does
Periodically, the system pulls current prices from the upstream model catalog for every model the platform offers. From those numbers it derives three things:
- Internal cost — what the model actually costs in local currency, using a weighted blend of input and output token rates.
- Sell price — the pay-as-you-go rate customers see, derived from cost plus margin.
- Token multiplier — the model’s relative price against a baseline model, which anchors subscription credit budgets.
The result is written to the live rate table and simultaneously to an audit snapshot — so at any point you can trace what changed, when, and from which upstream figures.
Spike guard: a brake on price jumps
This is the important part. When a model’s price moves by more than a configured threshold — say, a quarter — the sync does not apply it automatically. Instead it marks the rate as pending_review and waits for an admin to approve it.
Why? Because upstream catalogs can have temporary anomalies — an outage, a data error, a short-lived fluctuation. If that spike propagated straight into customer pricing, it would end up on invoices before anyone noticed.
The spike guard means routine price drift runs on its own, but anything unusual gets a human look first.
Estimate versus reality
The second problem the sync addresses: margin accuracy. When the system calculates how much it earned on a customer, it needs to know what the model actually cost — not what the system thought it cost based on the last sync.
The dashboard now separates two columns:
- Estimated cost — from the latest sync, always available.
- Real cost — the actual upstream price, when the system has it directly from the provider.
Margin is then computed from real cost wherever it exists. So the number on the dashboard isn’t “approximately right” — it’s right.
Why it’s not just a cron job and a table
At first glance, pricing sync looks simple: fetch JSON, recompute, save. In practice there are several edges worth mentioning:
- Cache pricing — some models don’t expose a cache-read price at the top catalog level, only at the individual provider level. The sync reads per-provider endpoints and takes the cheapest available cache price.
- Baseline anchor — the token multiplier is computed relative to a baseline model. If the baseline is missing from the catalog, the sync fails with a clear error rather than silently computing garbage.
- Audit trail — every sync writes a snapshot to the database. Not just “what is now”, but “what was before, what changed, and whether it passed review”.
Automating prices isn’t about stopping caring. It’s about caring about the right things — exceptions and anomalies — instead of rewriting spreadsheets.
Summary
The pricing sync on CoreSynth is a small but important piece of infrastructure. It keeps prices current, guards against anomalies, writes an audit trail, and gives the dashboard honest numbers. It’s invisible from the outside — but without it, billing is either manual labour or a silent source of errors.