# వినియోగ పరిమితులు

> ccam usage ప్రతి ఖాతా యొక్క 5 గంటల, వారపు పరిమితులను ఒకేసారి చూపిస్తుంది, ccam statusline ఖాతా పేరును, వినియోగాన్ని Claude Code లో చూపిస్తుంది.

Source: https://ccam.dev/te/features/usage/ · Updated 2026-10-19

ప్రతి ఖాతా 5 గంటల, వారపు పరిమితులలో ఎంత ఉపయోగించిందో, ప్రతి విండో రీసెట్ అయ్యే వరకు సమయంతో పాటు `ccam usage` చూపిస్తుంది. ఏ ఖాతాకు అవకాశం మిగిలి ఉందో చూడటానికి, పెద్ద పనిని మొదలుపెట్టే ముందు, లేదా పరిమితి దగ్గరలో ఉందని Claude Code చెప్పినప్పుడు దీన్ని ఉపయోగించండి. `ccam statusline` Claude Code కోసం స్టేటస్ లైన్ కమాండ్: ఇది Claude Code లోపల ఖాతా పేరును, వినియోగాన్ని చూపిస్తుంది, `ccam usage` కోసం సంఖ్యలను సేవ్ చేస్తుంది.

## వినియోగం

```sh
ccam usage                  # every account, once
ccam u                      # the same, shorter
ccam usage --watch          # redraw every 60 seconds until Ctrl+C
ccam usage --watch=10       # redraw every 10 seconds
ccam usage -v               # add per-model weekly limits and the data source
ccam usage --json           # machine-readable, one object per account
ccam usage --source cache   # saved numbers only, no network
ccam usage --refresh        # also renew expired logins of accounts not running
ccam statusline install     # set the status line in every account's settings.json
```

```console
$ ccam usage
 Account     5-hour        Resets    Weekly        Resets    As of
 1 personal  ░░░░░░░░   0% -         ██████░░  70% 2d 16h    9h 36m ago (cached)
 2 work      ██░░░░░░  24% 2h 29m    ███░░░░░  41% 3d 11h    just now (cached)
 3 side      login expired, run `ccam side` once to refresh
→ Most headroom: personal   (open it with ccam next --auto)
```

టెర్మినల్‌లో టేబుల్ ప్రతి వరుసలో `fetching…` తో వెంటనే కనిపిస్తుంది, ప్రతి ఖాతా సమాధానం ఇచ్చినప్పుడు దాని వరుస మళ్లీ గీయబడుతుంది. సంఖ్యలు ఎంత పాతవో `As of` చెబుతుంది; `(cached)` అంటే అవి ఎండ్‌పాయింట్ నుంచి కాకుండా సేవ్ చేసిన ఫైల్ నుంచి వచ్చాయి. చివరి లైన్ 100% కంటే తక్కువ ఉన్న, అతి తక్కువ 5 గంటల వినియోగం గల ఖాతా పేరును చెబుతుంది, మీకు ఒకటి కంటే ఎక్కువ ఖాతాలు ఉన్నప్పుడు మాత్రమే కనిపిస్తుంది. లాగిన్ కాని ఖాతా `not logged in → ccam login <name>` ను, API కీ ఖాతా `no limits (API)` ను చూపిస్తాయి.

`ccam statusline install` తర్వాత, Claude Code `[work] · Opus · 5h 24% · 7d 41%` వంటి లైన్‌ను చూపిస్తుంది.

## ఆప్షన్లు

| ఆప్షన్ | ఏమి చేస్తుంది | డిఫాల్ట్ |
| --- | --- | --- |
| `--json` | నివేదికలను JSON గా ప్రింట్ చేస్తుంది: `name`, `slot`, `status`, `limits`, `source`, `at`, `error` | ఆఫ్ |
| `--watch[=N]` | మీరు Ctrl+C నొక్కే వరకు ప్రతి `N` సెకన్లకు మళ్లీ గీస్తుంది. ఒంటరి `--watch`, లేదా 0 లేదా అంతకంటే తక్కువ విలువ అంటే 60 | ఆఫ్ |
| `-v`, `--verbose` | మోడల్ వారీ వారపు పరిమితులను, ఒక `source:` లైన్‌ను (`live`, `cache` లేదా `statusline`) చూపిస్తుంది | ఆఫ్ |
| `--no-cache` | 60 సెకన్ల కాష్‌ను పట్టించుకోకుండా ఎండ్‌పాయింట్‌ను మళ్లీ అడుగుతుంది | ఆఫ్ |
| `--source live\|cache` | `cache` ఎప్పుడూ ఎండ్‌పాయింట్‌ను అడగదు, సేవ్ చేసిన సంఖ్యలను మాత్రమే చూపిస్తుంది; `live` డిఫాల్ట్ ప్రవర్తన | live |
| `--refresh` | గడువు ముగిసిన యాక్సెస్ టోకెన్‌లను పునరుద్ధరిస్తుంది, రన్ అవ్వని ఖాతాలకు మాత్రమే | ఆఫ్ |
| `--dry-run` | అంగీకరిస్తుంది: `ccam usage` తన సొంత కాష్ తప్ప ఏదీ మార్చదు. `--refresh` తో కలిపి ఇస్తే తిరస్కరిస్తుంది: `--dry-run cannot be combined with --refresh, which rewrites login tokens` | ఆఫ్ |

మరే `--source` విలువైనా `--source must be live or cache` తో విఫలమవుతుంది. `ccam usage` ఆర్గ్యుమెంట్‌లు తీసుకోదు.

`ccam statusline` స్టాండర్డ్ ఇన్‌పుట్ నుంచి Claude Code స్టేటస్ లైన్ JSON ను చదువుతుంది. దాని ఏకైక ఆప్షన్ `--wrap <command>`: ఇప్పటికే ఉన్న స్టేటస్ లైన్ కమాండ్, దాని మొదటి అవుట్‌పుట్ లైన్ ముందు ఖాతా పేరు పెట్టబడుతుంది. `ccam statusline install` ఆప్షన్లు తీసుకోదు. రెండూ `--dry-run` ను `` --dry-run is not supported by `ccam statusline`; nothing was changed `` తో తిరస్కరిస్తాయి.

## ఇది ఎలా పనిచేస్తుంది

సంఖ్యలు రెండు చోట్ల నుంచి వస్తాయి: ప్రతి ఖాతా సొంత లాగిన్‌తో పిలిచే Anthropic యొక్క డాక్యుమెంట్ చేయని వినియోగ ఎండ్‌పాయింట్ `GET https://api.anthropic.com/api/oauth/usage`, Claude Code తన స్టేటస్ లైన్ కమాండ్‌కు అందించే విలువలు. ఇదంతా `internal/usage` లో ఉంటుంది.

1. `cli.usageCmd` `config.toml` ను లోడ్ చేసి, ప్రతి ఖాతాకు ఒక `usage.Account` ను తయారు చేస్తుంది: దాని ఫోల్డర్ `~/.local/share/ccam/profiles/<name>/`, దాని సెషన్ ఫోల్డర్ (అది రన్ అవుతుందో లేదో చూడటానికి), అది ఉన్న చోటే ఇంపోర్ట్ చేయబడిందా లేదా.
2. `Fetcher.FetchAll` ప్రతి ఖాతాకు ఒక goroutine ను ప్రారంభిస్తుంది. అవన్నీ ఒకే `http.Client` ను షేర్ చేస్తాయి, కాబట్టి ఎండ్‌పాయింట్‌కు కనెక్షన్‌లు మళ్లీ ఉపయోగించబడతాయి. కనెక్ట్ అవ్వడానికి 2 s పట్టవచ్చు, ప్రతి ఖాతాకు మొత్తం 3 s లభిస్తాయి. రీడైరెక్ట్ టోకెన్‌ను వేరే చోటికి మళ్లీ పంపుతుంది కాబట్టి క్లయింట్ రీడైరెక్ట్‌లను అనుసరించదు, సమాధానంలో గరిష్ఠంగా 1 MB మాత్రమే చదువుతుంది.
3. ప్రతి ఖాతా పూర్తయినప్పుడు, దాని వరుస మళ్లీ గీయబడుతుంది. విఫలమైన లేదా సమయానికి సమాధానం ఇవ్వని ఖాతా సేవ్ చేసిన సంఖ్యలకు మారుతుంది, కాబట్టి ఒక నెమ్మదైన ఖాతా ఎప్పుడూ ఇతరులను ఆపదు.

ప్రతి ఖాతా ఎండ్‌పాయింట్‌కు వ్యతిరేకంగా తన సొంత goroutine లో రన్ అవుతుంది; సమయం మించిన ఖాతా బదులుగా తన సేవ్ చేసిన సంఖ్యలను చూపిస్తుంది.

`personal`, `work` సమయానికి సమాధానం ఇచ్చి లైవ్ సంఖ్యలను చూపిస్తాయి. `side` కు 3 s కంటే ఎక్కువ పడుతుంది, కాబట్టి `fallback()` దాని రెండు కాష్ ఫైళ్లను చదివి, చివరిగా రాసినదాన్ని ఉపయోగిస్తుంది. `usage.Table()` వరుసలను గీస్తుంది, `usage.Best()` చివరి లైన్‌లో పేర్కొన్న ఖాతాను ఎంచుకుంటుంది.

ఒక ఖాతా కోసం, `Fetcher.Fetch` ఈ తనిఖీలను క్రమంగా చేస్తుంది:

1. `--source cache` తో, అది నేరుగా `fallback()` కు వెళ్తుంది.
2. `--no-cache` సెట్ కాకపోతే, `~/.local/state/ccam/usage/<name>.json` లో 60 సెకన్ల (`CacheTTL`) కంటే కొత్తదైన లైవ్ ఫలితం ఉన్నది ఉన్నట్లుగా తిరిగి ఇవ్వబడుతుంది. `ccam usage` ను వరుసగా రెండుసార్లు రన్ చేస్తే ఒక్కో ఖాతాకు ఒక అభ్యర్థన మాత్రమే.
3. `readCredentials()` `.credentials.json` ను (లేదా macOS Keychain ను) మార్చకుండా చదువుతుంది, `claudeAiOauth` కీ మాత్రమే డీకోడ్ చేయబడుతుంది. సబ్‌స్క్రిప్షన్ లాగిన్ లేకపోతే `not logged in`, లేదా `.claude.json` లో API కీ ఉంటే `no limits (API)`.
4. గడువు ముగిసిన యాక్సెస్ టోకెన్ ఉపయోగించబడదు. `--refresh` లేకుండా, ఖాతా గడువు ముగిసినదిగా గుర్తించిన తన సేవ్ చేసిన సంఖ్యలను చూపిస్తుంది.
5. లేకపోతే ccam ఎండ్‌పాయింట్‌ను పిలుస్తుంది. 401 లేదా 403 గడువు ముగిసిన లాగిన్‌గా, మరే ఇతర స్టేటస్ లేదా చదవలేని బాడీ ఎర్రర్‌గా లెక్కించబడతాయి, రెండూ సేవ్ చేసిన సంఖ్యలకు మారతాయి.
6. మంచి సమాధానం అది కొలిచిన సమయంతో `<name>.json` లో రాయబడుతుంది.

`fallback()` `<name>.json`, `<name>.statusline.json` రెండింటినీ చదివి కొత్తదాన్ని ఉంచుతుంది. సేవ్ చేసిన సంఖ్యలను చూపించే ముందు, అది ప్రతి విండో రీసెట్ సమయాన్ని తనిఖీ చేస్తుంది: సంఖ్యలు సేవ్ అయినప్పటి నుంచి రీసెట్ అయిన విండో 0% చూపిస్తుంది, ఎందుకంటే పాత శాతం ఇక చెల్లదు. అందుకే పైన `personal` రీసెట్ సమయం లేకుండా `0%` చూపిస్తుంది.

ఎండ్‌పాయింట్‌కు రెండు రెస్పాన్స్ ఫార్మాట్‌లు ఉన్నాయి. కొత్తదానిలో `session` (5 గంటలు), `weekly_all`, `weekly_scoped` (మోడల్ వారీ) ఎంట్రీలతో `limits` అర్రే ఉంటుంది. పాతదానిలో `five_hour`, `seven_day`, `seven_day_opus`, `seven_day_sonnet` ఆబ్జెక్ట్‌లు ఉంటాయి. `ParseLive` రెండింటినీ చదువుతుంది: `limits` అర్రే గెలుస్తుంది, అది కవర్ చేయని వాటిని పాత ఆబ్జెక్ట్‌లు నింపుతాయి. అసలు పరిమితులే లేని బాడీ మారిన ఫార్మాట్‌గా నివేదించబడుతుంది, దాని గురించి `ccam doctor` మీకు చెబుతుంది.

### టోకెన్‌లను పునరుద్ధరించడం

రిఫ్రెష్ టోకెన్‌లు మారుతూ ఉంటాయి: ఒకదాన్ని పునరుద్ధరిస్తే మీకు కొత్త రిఫ్రెష్ టోకెన్ లభిస్తుంది, పాతది చెల్లకుండా పోతుంది. అదే ఖాతాగా Claude Code రన్ అవుతున్నప్పుడు ccam లాగిన్‌ను పునరుద్ధరిస్తే, ఆ సెషన్ సైన్ అవుట్ అవుతుంది. కాబట్టి మీరు `--refresh` ఇస్తే తప్ప, `ccam usage` టోకెన్‌లను చదువుతుంది, ఎప్పుడూ రాయదు. అప్పుడు `Fetcher.refresh`:

1. `ccam import` తో ఉన్న చోటే నమోదైన ఖాతాలను తిరస్కరిస్తుంది, ఎందుకంటే ccam కు తెలియకుండా సాధారణ `claude` ఆ లాగిన్‌ను ఉపయోగించవచ్చు;
2. macOS Keychain లో నిల్వ ఉన్న లాగిన్‌లను తిరస్కరిస్తుంది;
3. ఒక లాక్ ఫైల్‌ను తీసుకుంటుంది, `$XDG_RUNTIME_DIR/ccam/profile-<name>.refresh.lock` (ఆ వేరియబుల్ సెట్ కానప్పుడు `~/.local/state/ccam/locks/` కింద), కాబట్టి రెండు ccam ప్రాసెస్‌లు ఒకే టోకెన్‌ను ఎప్పుడూ రెండుసార్లు పునరుద్ధరించవు;
4. లాక్ కింద, ఖాతా సెషన్ రన్ అవుతుంటే తిరస్కరిస్తుంది, మరో ప్రాసెస్ ఇప్పటికే టోకెన్‌ను పునరుద్ధరించి ఉంటే అభ్యర్థనను దాటవేస్తుంది;
5. రిఫ్రెష్ టోకెన్‌ను టోకెన్ ఎండ్‌పాయింట్‌కు పంపి, ఫైల్‌లోని ప్రతి ఇతర కీని ఉంచుతూ, కొత్త టోకెన్‌లను `fsutil.AtomicWrite` తో `.credentials.json` లో తిరిగి రాస్తుంది.

### స్టేటస్ లైన్ కలెక్టర్

Claude Code స్టేటస్ లైన్ కమాండ్‌ను రన్ చేసి దానికి ఒక JSON డాక్యుమెంట్‌ను పైప్ చేస్తుంది. ccam దాని నుంచి మోడల్ పేరును, `rate_limits` ను చదువుతుంది:

1. `runStatusline` Claude Code ను ప్రారంభించేటప్పుడు ccam సెట్ చేసే `CCAM_PROFILE` నుంచి, లేకపోతే `CLAUDE_CONFIG_DIR` ను ఖాతా ఫోల్డర్‌లతో సరిపోల్చి, ఖాతాను కనుగొంటుంది.
2. `ParseStatusLine` `rate_limits.five_hour`, `rate_limits.seven_day` ను చదువుతుంది. API కీ ఖాతాలకు, లేదా సెషన్ మొదటి రెస్పాన్స్‌కు ముందు, JSON లో రేట్ లిమిట్‌లు ఉండవు; అప్పుడు ఏదీ సేవ్ కాదు.
3. `SaveStatusLine` `~/.local/state/ccam/usage/<name>.statusline.json` ను రాస్తుంది. ఎండ్‌పాయింట్ సమాధానం ఇవ్వనప్పుడు `ccam usage` దాన్ని ఉపయోగిస్తుంది.
4. ccam `[name] · model · 5h N% · 7d N%` ను ప్రింట్ చేస్తుంది. `--wrap` తో, అది అదే ఇన్‌పుట్‌తో `sh -c` ద్వారా మీ కమాండ్‌ను రన్ చేసి, బదులుగా `[name]` తో పాటు కమాండ్ మొదటి లైన్‌ను ప్రింట్ చేస్తుంది.

వ్రాప్ చేసిన కమాండ్‌కు 2 సెకన్లు లభిస్తాయి. ఆ తర్వాత అది ఆపివేయబడుతుంది, లైన్ ఖాతా పేరును మాత్రమే చూపిస్తుంది, కాబట్టి నెమ్మదైన కమాండ్ Claude Code స్టేటస్ లైన్‌ను అడ్డుకోలేదు.

`ccam statusline install` ప్రతి ఖాతా `settings.json` లో `statusLine` ను రాస్తుంది. ఒక ఖాతాకు ఇప్పటికే స్టేటస్ లైన్ కమాండ్ ఉంటే, ccam దాన్ని `--wrap '<old command>'` గా ఉంచుతుంది. గ్రూప్ ద్వారా షేర్ చేసిన `settings.json` దాని లింక్ ద్వారా ఒకసారి రాయబడుతుంది, కాబట్టి గ్రూప్‌లోని ప్రతి ఖాతాకు అది అందుతుంది. దాన్ని మళ్లీ రన్ చేస్తే ఇప్పటికే ccam ను ఉపయోగిస్తున్న ఫైళ్లకు `(already set)` అని ప్రింట్ అవుతుంది.

## భద్రత, ప్రత్యేక సందర్భాలు

- మీరు `--refresh` ఇస్తే తప్ప `ccam usage` ఎప్పుడూ టోకెన్ ఫైల్‌ను మార్చదు. లాగిన్ గడువు ముగిసినప్పుడు, ఆ ఖాతాను `ccam <name>` తో ఒక్కసారి రన్ చేయండి, Claude Code దాన్ని పునరుద్ధరిస్తుంది.
- `--refresh` రన్ అవుతున్న ఖాతాలను, ఇంపోర్ట్ చేసిన ఖాతాలను, Keychain లాగిన్‌లను ఎప్పుడూ ముట్టుకోదు. తిరస్కరించిన రిఫ్రెష్ సేవ్ చేసిన సంఖ్యలను, కారణాన్ని చూపిస్తుంది.
- వినియోగ ఎండ్‌పాయింట్ బహిరంగంగా డాక్యుమెంట్ చేయబడలేదు, మారవచ్చు. అది మారినప్పుడు, మీకు ఇంకా సేవ్ చేసిన సంఖ్యలు కనిపిస్తాయి, `ccam doctor` ఫార్మాట్ మార్పును నివేదిస్తుంది.
- సేవ్ చేసిన సంఖ్యలు, సమాధానం రెండూ లేకపోతే, వరుస `lookup failed:` ను, కారణాన్ని చూపిస్తుంది, ఉదాహరణకు `--source cache` తో `no saved usage`.
- కాష్ ఫైళ్లలో శాతాలు, రీసెట్ సమయాలు మాత్రమే ఉంటాయి, ఎప్పుడూ టోకెన్‌లు ఉండవు.

## సంబంధిత పేజీలు

- [వినియోగ పరిమితులు, ఖాతాలు మార్చడం](https://ccam.dev/te/docs/usage-limits.md)
- [తదుపరి ఖాతాకు మారడం](https://ccam.dev/te/features/next.md)
- [వినియోగ పరిమితి వర్క్‌ఫ్లో](https://ccam.dev/te/guides/usage-limit-workflow.md)
- [కమాండ్‌లు](https://ccam.dev/te/docs/commands.md)