Usage Management & Cost Optimization: Credits, Console, and Model Selection

PingAI uses a unified credits billing model (1 credit = HK$1): every request is converted into credits from the model's input / output price × tokens, charged against your subscription quota or pay-as-you-go balance.

• Billing basis: credits = model price × prompt_tokens + model price × completion_tokens
• Different models cost different amounts — pricey models (e.g. opus) drain faster, cheap ones (e.g. haiku) slower
• Every request shows its spend (HK$) on the Console usage page

The benefit: you never convert per-model token pricing yourself — one credits concept covers everything.

PingAI currently serves the full Claude line (official rates, per 1M tokens):

• claude-haiku-4.5: input $1 / output $5 — fastest and cheapest, for simple tasks
• claude-sonnet-5: input $3 / output $15 — the workhorse, balancing speed, cost, and capability
• claude-opus-5: input $5 / output $25 — complex reasoning, hard tasks
• claude-fable-5: input $10 / output $50 — strongest capability, premium price
• Older versions: claude-sonnet-4 / claude-opus-4 / claude-opus-4.8 / claude-sonnet-4.6 also available

Pricing is subject to the pricing page; actual deductions convert via PingAI's HKD rate table into credits.

Two ways to pay:

• Subscription: a fixed monthly amount (e.g. tiers at HK$188 / 938 / 1888) with a monthly credits quota and optional team seats; suits steady, predictable usage
• Pay-as-you-go (top-up): prepay into a balance and deduct per request, no monthly fee; suits trials, low usage, or volatile workloads

How to choose:

• Daily requests → the subscription is usually cheaper
• Occasional / trying it out → pay-as-you-go
• Exact tiers, included quota, and seat rules follow the pricing page — this course covers the concept

The most important habit after connecting: check usage regularly. The Console usage page provides:

• Request count and total spend (HK$): the two core numbers for "how much did I use, how much did it cost"
• Average daily requests / spend
• By-model breakdown: which models consume the most requests — the basis for tuning your model strategy
• Time-window switch: "last 7 / 30 / 90 days", great for spotting trends
• CSV export: pull data down for your own analysis or reconciliation

The Dashboard overview also shows remaining credits / quota progress at a glance.

To avoid surprise bills, set limits in the Console early:

• Key billing mode: choose "subscription quota" (against plan credits) or "pay-as-you-go" (against balance)
• Budget cap: each key can carry an HK$ budget; spending stops when it is hit
• RPM throttling: PingAI's routing layer enforces per-minute request (RPM) and concurrency controls so a single key cannot saturate resources
• Circuit breakers and ordered degradation: if one upstream fails, traffic automatically falls over to the next — no single point of failure stops the service

Recommendation: keep production and development keys separate, each with its own budget, so a single key can be revoked instantly if something goes wrong.

The most direct way to save is "the cheapest model that gets the job done":

• Simple tasks (translation, summarization, classification, formatting) → claude-haiku-4.5
• Everyday coding, writing, Q&A, agent main loops → claude-sonnet-5 (the workhorse)
• Complex reasoning, long-document analysis, hard debugging → claude-opus-5
• When you need maximum capability and can afford it → claude-fable-5

Practical advice:

• Try sonnet first; escalate to opus only when the task is too hard
• Pin repetitive tasks to haiku to save a lot
• In Claude Code you can type /model to switch models on the fly until it fits

Tokens are the billing unit, so controlling tokens controls cost:

• max_tokens: cap output length to stop rambling / runaway generation
• Slim the system prompt: it counts as input tokens on every request; shorter means more savings
• Cut unnecessary context: longer context means more input tokens (input is billed too)
• Do not stuff whole files into the prompt — bring only the parts you need
• Streamed output with sane parameters avoids double cost from retries

For example, slimming a system prompt from 2,000 to 500 tokens saves 1,500 input tokens per request; at 1,000 requests a day that is 1.5M tokens — do not underestimate these "small wins".

Beyond controlling tokens, think about "how you run":

• Tier your tasks: low-value requests (e.g. bulk classification) run haiku; high-value requests run sonnet / opus
• Set retry policies: cap retries on retriable tasks so failures do not burn credits in a retry loop
• Upstream failover is built into PingAI: when an upstream is unstable it switches to the next in line automatically — you do not write your own failover
• Watch usage trends: if one model explodes, use the by-model breakdown to adjust early

Remember to review Console usage periodically — cost optimization is an ongoing process, not a one-time setup.

To verify invoices or attribute cost, use:

• CSV export on the Console usage page: daily request counts and spend (HK$), ideal for monthly reconciliation
• By-model breakdown: department / project cost attribution (combined with separate keys)
• Request details: prompt / completion tokens per request to track abnormally large ones

Reconciliation workflow:

1. 1At the start of each month, review last month's total spend against plan quota
2. 2Pick out the largest requests and check for anomalies (e.g. a poisoned long prompt)
3. 3If in doubt, discuss with support using the request details

• Why does this request cost different from last time? — model, token counts, and system prompt length all matter; compare the request details
• How does the plan quota work? — remaining monthly credits show in the Console; exact cycle rules follow the plan terms
• What happens when quota / balance runs out? — requests fail with 429; top up or upgrade to resume
• Can I cap spending? — yes, set an HK$ budget per key and choose the right billing mode
• Is there a refund policy? — follow the terms and pricing page; contact support if you have questions

In short: understand credits, check usage regularly, and pick models by task — those are the three pillars of cost control.