If you budget AI spend in rupees, two things move your bill without any change in your code: the vendor's price list and the USD to INR rate. Most teams find out when the invoice arrives. AICredits publishes its whole catalog, with INR prices, at a public URL, which makes a price tracker a 60-line script. This post gives you the script, shows it working on real and synthetic data, and sets it up to run daily.
Disclosure: AICredits links on this site are affiliate links. The tracker reads the public catalog and does not need an account. Whether your wallet is debited exactly the catalog price is something I could not verify; see the cost-per-feature post.
What does the catalog give you to diff?
GET https://api.aicredits.in/v1/models returned 432 entries on 2026-10-16 with, per model: input_cost_per_token_inr, output_cost_per_token_inr, cached_input_cost_per_token_inr, exchange_rate, context_length, supported_apis and last_updated. A snapshot is just that JSON saved with the date. At about 360 KB, a year of daily snapshots is roughly 130 MB uncompressed, and JSON compresses well. If that matters, keep only the fields you need.
The diff script
It loads two snapshots, indexes them by model ID, and reports added models, removed models, the exchange rates present, and INR price changes at or above a threshold (default 1 percent) for input and output prices.
def diff(old, new, min_pct=1.0):
out = {"added": sorted(set(new) - set(old)), "removed": sorted(set(old) - set(new)), "changed": []}
for mid in sorted(set(old) & set(new)):
for k in ("input_cost_per_token_inr", "output_cost_per_token_inr"):
a, b = per_m(old[mid], k), per_m(new[mid], k)
if a and b and abs(b - a) / a * 100 >= min_pct:
out["changed"].append((mid, k.split("_")[0], a, b, (b - a) / a * 100))
rates = {m["exchange_rate"] for m in old.values()}, {m["exchange_rate"] for m in new.values()}
out["rate"] = (sorted(rates[0]), sorted(rates[1]))
return out
Prices are shown per million tokens in rupees. The if a and b guard skips models with a missing or zero price, such as image and audio entries that use a different pricing structure.
What did it find on real data?
I fetched the catalog twice on 2026-10-16, a few hours apart, and diffed them:
REAL (two fetches, hours apart, same day):
added: 0 []
removed: 0 []
exchange rate: [95.10014] -> [95.10014]
price changes >= threshold: 0
Nothing changed within a day, which is a useful result by itself: the script reports no false alarms on identical data. It cannot tell you what happens over weeks, because I only have one day of real snapshots. I will not invent a trend.
Does the script catch changes when they happen?
To test detection I made a synthetic "next day" file from the real snapshot: removed two models, added one, cut one model's prices by 30 percent, raised another's by 20 percent, nudged a third by 0.5 percent (below the threshold), and moved the exchange rate to 95.9. None of this is real. Output:
SYNTHETIC:
added: 1 ['openai/gpt-6-luna-mini']
removed: 2 ['mistralai/mistral-nemo', 'openai/o1-pro']
exchange rate: [95.10014] -> [95.9]
price changes >= threshold: 4
openai/gpt-6-luna input Rs 9.99 -> 6.99 (-30.0%)
openai/gpt-6-luna output Rs 49.93 -> 34.95 (-30.0%)
anthropic/claude-sonnet-5.5 input Rs 199.71 -> 239.65 (+20.0%)
anthropic/claude-sonnet-5.5 output Rs 998.55 -> 1198.26 (+20.0%)
It found the added and removed models, the rate move and both price changes, and correctly ignored the 0.5 percent nudge. The synthetic prices describe my test, not any real change to these models.
Why not just use last_updated?
I checked how that field is distributed. Of 432 models, 333 had a last_updated within three days of 2026-10-16, and the busiest hour, 2026-10-13T18, accounted for all 333. Another 86 models were last updated in June 2026. A single hour touching 333 entries looks like a bulk refresh job, which is my inference and not something the catalog states. The practical point holds either way: the timestamp tells you a record was written, not that a price changed. Diff the values.
How do you run it daily?
A scheduled GitHub Actions job is the simplest. I did not run this workflow, so treat it as a starting point and test it in a private repository first:
name: catalog-snapshot
on:
schedule: [{ cron: "30 3 * * *" }]
workflow_dispatch: {}
jobs:
snap:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: mkdir -p snapshots && curl -sS -m 60 https://api.aicredits.in/v1/models -o snapshots/$(date -u +%F).json
- run: python catalog_diff.py $(ls snapshots/*.json | tail -2 | head -1) $(ls snapshots/*.json | tail -1) --min-pct 1 | tee diff.txt
- run: |
git config user.name bot && git config user.email bot@example.com
git add snapshots && git commit -m "snapshot" && git push
Ideas to extend it: post the diff to Slack or email only when it is non-empty, keep a CSV of your own models' prices over time, and alert when the exchange rate moves more than a set amount.
What do you do with a price change?
- Re-run your cost report with fresh prices. The usage-log script takes the catalog as input.
- Check whether the shortlist changed. The model picker re-ranks with current prices.
- Update customer pricing if you resell AI features. The gross margin calculator shows the effect of cost changes.
- Watch removals. A removed model ID will start returning errors in production. The retry and fallback wrapper can switch to a replacement.
For vendors' own price lists, see AI model pricing 2026. The AICredits signup is an affiliate link.
What I could not verify
- How often AICredits really changes prices. I have one day of real data.
- That the GitHub Actions workflow runs as written.
- That the catalog endpoint and its fields will stay as they are.
