A monthly total tells you nothing you can act on. What you can act on is "contract summaries cost nine rupees a call and support chat costs three paise". This post gives you a script that turns a usage log into rupees per feature, using prices that AICredits publishes openly, and reports what I found when I compared the catalog's INR prices with its USD prices.
Disclosure: AICredits links on this site are affiliate links. The usage log in the demo is invented, so the rupee figures describe a made-up workload, not any real app. The prices are real: I fetched the public catalog on 2026-10-16.
What does the catalog give you?
GET https://api.aicredits.in/v1/models returned 432 models without authentication. Each entry has, among other fields:
id, for exampleopenai/gpt-6-lunainput_cost_per_token,output_cost_per_token,cached_input_cost_per_tokenin USD- the same three in INR with an
_inrsuffix exchange_rate(95.10014 on every entry that day)context_length,mode,supported_apis,last_updated
So you do not have to hand-copy a price table that goes stale. Fetch, then compute.
How do you turn a usage log into rupees?
Every chat completion response carries a usage block with prompt and completion tokens, and (for providers that report it) cached tokens. Log those three numbers with a feature tag and the model ID on every call. The script below then prices each row:
def cost_inr(model, prompt, cached, completion):
m = catalog[model]
pin = m["input_cost_per_token_inr"]
pc = m.get("cached_input_cost_per_token_inr") or pin # no cache price: assume full price
pout = m["output_cost_per_token_inr"]
return (prompt - cached) * pin + cached * pc + completion * pout
The log format is one row per call: feature, model, prompt tokens (including cached), cached tokens, completion tokens. Reasoning models may bill reasoning tokens inside the completion count; check your provider's usage fields rather than assuming.
What does the report look like?
I wrote nine invented calls across three features and ran the script against the real catalog prices:
feature calls total Rs Rs/call Rs/1000 calls
contract-summary 2 18.7728 9.3864 9386.38
support-chat 3 0.0944 0.0315 31.45
tag-classifier 4 0.0860 0.0215 21.49
TOTAL 9 18.9531
I checked one row by hand: a 42,000-token summary on anthropic/claude-sonnet-5.5 at Rs 199.71 per million input tokens is Rs 8.39, plus 1,500 output tokens at Rs 998.55 per million is Rs 1.50, so about Rs 9.89. The report's per-call figure for the two summaries averages to 9.39, which fits with the second, smaller call.
The lesson sits in the last column. Per 1,000 calls, the summary feature costs about 300 times the support chat in this made-up workload. If you had budgeted by "number of API calls", you would have missed it. Where would you optimise? In the summary: shorter input, a cheaper model for first-pass summaries, or prompt caching if the same document is queried repeatedly.
What is the markup between USD and INR prices?
I computed, for all 413 catalog models that have a USD input price, the ratio input_cost_per_token_inr / (input_cost_per_token * exchange_rate). Every one came out at exactly 1.05. So in the catalog data, the INR price is the USD price, times the exchange rate, times 1.05.
The USD prices themselves look like the providers' list prices: I compared five Anthropic models with Anthropic's pricing page on the same day. Sonnet 4.6 ($3 input, $15 output), Haiku 4.5 ($1 and $5), Opus 4.8 ($5 and $25), Opus 5.5 ($4 and $20) and Fable 5.1 ($10 and $50) all matched. One difference: for Sonnet 5.5, Anthropic's table listed a $0.10 cache hit price with a footnote I did not read, while the catalog listed $0.20. That is a good example of why to reconcile against a real invoice.
What the AICredits homepage says about fees: pricing is "live forex rate + 5% buffer", with a small-print line that prices include a 5% forex buffer and a 5% platform fee. I cannot tell from public data whether the wallet is debited exactly the catalog INR price. If the 1.05 factor already includes everything, the catalog is your bill. If another fee applies on top, your real costs are higher than this script reports. One real invoice line settles it. Do that before you quote customers.
How do you keep spend under control?
AICredits' homepage lists per-key rate limits and spend budgets, team credit allocation with per-person caps, and low-balance alerts, and says the wallet balance is a hard ceiling. I did not test any of these, so check the dashboard for how the limits behave. Whatever the gateway offers, put three safeguards in your own code:
- Log usage on every call, including failures that were billed.
- Set a daily budget in code per feature and stop calling when it is hit. The approval gate pattern shows a call budget.
- Alert on the Rs/call trend, not only the total. A prompt that quietly doubled in length shows up there first.
For a worked set of per-request cost examples, see LLM API cost per 1,000 requests. If you charge customers for AI features, the gross margin calculator takes this per-call cost as an input, and LiteLLM proxy budgets and virtual keys covers another way to cap spend. The AICredits signup is an affiliate link.
What I could not verify
- That wallet debits equal catalog prices. This needs real usage.
- How AICredits reports cached tokens in
usagefor each provider. - That the budget caps and alerts behave as the homepage describes.
- Prices on any day but 2026-10-16. Fetch fresh data before use.
