# பயன்பாட்டு வரம்புகள்

> ccam usage எல்லாக் கணக்குகளின் 5 மணி நேர, வாராந்திர வரம்புகளையும் ஒரே நேரத்தில் காட்டுகிறது, ccam statusline கணக்கின் பெயரையும் பயன்பாட்டையும் Claude Code-இல் காட்டுகிறது.

Source: https://ccam.dev/ta/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)` என்றால் அவை endpoint-இலிருந்து அல்ல, சேமிக்கப்பட்ட கோப்பிலிருந்து வருகின்றன. கடைசி வரி 100%-க்குக் கீழே மிகக் குறைந்த 5 மணி நேரப் பயன்பாடு உள்ள கணக்கைப் பெயரிடும், உங்களிடம் ஒன்றுக்கு மேற்பட்ட கணக்குகள் இருந்தால் மட்டுமே அது தோன்றும். உள்நுழையாத கணக்கு `not logged in → ccam login <name>` எனக் காட்டும், API key கணக்கு `no limits (API)` எனக் காட்டும்.

`ccam statusline install`-க்குப் பிறகு, Claude Code `[work] · Opus · 5h 24% · 7d 41%` போன்ற ஒரு வரியைக் காட்டும்.

## Options

| Option | என்ன செய்யும் | இயல்புநிலை |
| --- | --- | --- |
| `--json` | அறிக்கைகளை JSON ஆக அச்சிடும்: `name`, `slot`, `status`, `limits`, `source`, `at`, `error` | off |
| `--watch[=N]` | நீங்கள் Ctrl+C அழுத்தும் வரை ஒவ்வொரு `N` வினாடிக்கும் மீண்டும் வரையும். `--watch` மட்டும், அல்லது 0 அல்லது அதற்குக் குறைவான மதிப்பு, 60 எனப் பொருள்படும் | off |
| `-v`, `--verbose` | model-வாரியான வாராந்திர வரம்புகளையும் ஒரு `source:` வரியையும் (`live`, `cache` அல்லது `statusline`) காட்டும் | off |
| `--no-cache` | 60 வினாடி cache-ஐப் புறக்கணித்து endpoint-இடம் மீண்டும் கேட்கும் | off |
| `--source live\|cache` | `cache` ஒருபோதும் endpoint-இடம் கேட்காது, சேமித்த எண்களை மட்டுமே காட்டும்; `live` இயல்புநிலை நடத்தை | live |
| `--refresh` | காலாவதியான access tokens-ஐப் புதுப்பிக்கும், இயங்காத கணக்குகளுக்கு மட்டும் | off |
| `--dry-run` | ஏற்கப்படும்: `ccam usage` தன் சொந்த cache-ஐத் தவிர எதையும் மாற்றுவதில்லை. `--refresh` உடன் சேர்த்தால் மறுக்கப்படும்: `--dry-run cannot be combined with --refresh, which rewrites login tokens` | off |

வேறு எந்த `--source` மதிப்பும் `--source must be live or cache` என்று தோல்வியடையும். `ccam usage` எந்த argument-ஐயும் ஏற்காது.

`ccam statusline` Claude Code-இன் நிலை வரி JSON-ஐ standard input-இலிருந்து படிக்கிறது. அதன் ஒரே option `--wrap <command>`: ஏற்கெனவே உள்ள ஒரு நிலை வரிக் கட்டளை, அதன் வெளியீட்டின் முதல் வரிக்கு முன் கணக்கின் பெயர் சேர்க்கப்படும். `ccam statusline install` எந்த option-ஐயும் ஏற்காது. இரண்டும் `--dry-run`-ஐ `` --dry-run is not supported by `ccam statusline`; nothing was changed `` என்று மறுக்கும்.

## இது எப்படி வேலை செய்கிறது

எண்கள் இரண்டு இடங்களிலிருந்து வருகின்றன: ஒவ்வொரு கணக்கின் சொந்த உள்நுழைவுடன் அழைக்கப்படும் Anthropic-இன் ஆவணப்படுத்தப்படாத usage endpoint `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`-ஐப் பகிர்கின்றன, அதனால் endpoint-க்கான இணைப்புகள் மீண்டும் பயன்படுத்தப்படுகின்றன. இணைப்புக்கு 2 s ஆகலாம், ஒவ்வொரு கணக்குக்கும் மொத்தம் 3 s கிடைக்கும். redirect token-ஐ வேறிடத்துக்கு மீண்டும் அனுப்பிவிடும் என்பதால் client redirects-ஐப் பின்தொடராது, பதிலில் அதிகபட்சம் 1 MB மட்டுமே படிக்கும்.
3. ஒவ்வொரு கணக்கும் முடியும்போது, அதன் வரிசை மீண்டும் வரையப்படும். தோல்வியடையும் அல்லது நேரத்துக்குள் பதில் அளிக்காத கணக்கு சேமித்த எண்களுக்குத் திரும்பும், அதனால் ஒரு மெதுவான கணக்கு மற்றவற்றை ஒருபோதும் தாமதப்படுத்தாது.

ஒவ்வொரு கணக்கும் endpoint-க்கு எதிராகத் தன் சொந்த goroutine-இல் இயங்குகிறது; நேரம் கடந்துவிடும் கணக்கு அதற்குப் பதிலாகச் சேமித்த எண்களைக் காட்டும்.

`personal` மற்றும் `work` நேரத்துக்குள் பதில் அளித்து நேரடி எண்களைக் காட்டுகின்றன. `side` 3 s-க்கு மேல் எடுக்கிறது, அதனால் `fallback()` அதன் இரண்டு cache கோப்புகளைப் படித்து, கடைசியாக எழுதப்பட்டதைப் பயன்படுத்துகிறது. `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` key மட்டுமே decode செய்யப்படுகிறது. subscription உள்நுழைவு இல்லையென்றால் `not logged in`, அல்லது `.claude.json`-இல் API key இருந்தால் `no limits (API)`.
4. காலாவதியான access token பயன்படுத்தப்படுவதில்லை. `--refresh` இல்லாமல், கணக்கு காலாவதி எனக் குறிக்கப்பட்ட சேமித்த எண்களைக் காட்டும்.
5. இல்லையென்றால் ccam endpoint-ஐ அழைக்கிறது. 401 அல்லது 403 காலாவதியான உள்நுழைவாகக் கருதப்படும், வேறு எந்த status-உம் அல்லது படிக்க முடியாத body-உம் பிழையாகக் கருதப்படும், இரண்டுமே சேமித்த எண்களுக்குத் திரும்பும்.
6. சரியான பதில், அது அளவிடப்பட்ட நேரத்துடன் `<name>.json`-இல் எழுதப்படும்.

`fallback()` `<name>.json`, `<name>.statusline.json` இரண்டையும் படித்து, புதியதை வைத்துக்கொள்கிறது. சேமித்த எண்களைக் காட்டும் முன், அது ஒவ்வொரு கால அளவின் மீட்டமைப்பு நேரத்தையும் சரிபார்க்கிறது: எண்கள் சேமிக்கப்பட்ட பிறகு மீட்டமைக்கப்பட்ட கால அளவு 0% எனக் காட்டும், ஏனெனில் பழைய சதவீதம் இனி பொருந்தாது. அதனால்தான் மேலே உள்ள `personal` மீட்டமைப்பு நேரம் இல்லாமல் `0%` காட்டுகிறது.

endpoint-க்கு இரண்டு பதில் வடிவங்கள் உள்ளன. புதியதில் `session` (5 மணி நேரம்), `weekly_all`, `weekly_scoped` (model-வாரியாக) உள்ளீடுகளுடன் ஒரு `limits` array உள்ளது. பழையதில் `five_hour`, `seven_day`, `seven_day_opus`, `seven_day_sonnet` objects உள்ளன. `ParseLive` இரண்டையும் படிக்கிறது: `limits` array முன்னுரிமை பெறும், அது உள்ளடக்காதவற்றைப் பழைய objects நிரப்பும். வரம்புகளே இல்லாத body மாறிய வடிவமாகத் தெரிவிக்கப்படும், அதைப் பற்றி `ccam doctor` உங்களுக்குச் சொல்லும்.

### Tokens-ஐப் புதுப்பித்தல்

Refresh tokens சுழற்சி முறையில் மாறும்: ஒன்றைப் புதுப்பித்தால் புதிய refresh token கிடைக்கும், பழையது செல்லாததாகிவிடும். அதே கணக்காக Claude Code இயங்கிக்கொண்டிருக்கும்போது ccam உள்நுழைவைப் புதுப்பித்தால், அந்த அமர்வு வெளியேற்றப்படும். அதனால் நீங்கள் `--refresh` கொடுக்காதவரை, `ccam usage` tokens-ஐப் படிக்கும், ஒருபோதும் எழுதாது. கொடுத்தால் `Fetcher.refresh`:

1. `ccam import` மூலம் இருந்த இடத்திலேயே பதிவுசெய்யப்பட்ட கணக்குகளை மறுக்கும், ஏனெனில் ccam-க்குத் தெரியாமல் வெறும் `claude` அந்த உள்நுழைவைப் பயன்படுத்தக்கூடும்;
2. macOS Keychain-இல் சேமிக்கப்பட்ட உள்நுழைவுகளை மறுக்கும்;
3. இரண்டு ccam processes ஒரே token-ஐ இருமுறை புதுப்பிக்காமல் இருக்க, `$XDG_RUNTIME_DIR/ccam/profile-<name>.refresh.lock` என்ற lock கோப்பை எடுக்கும் (அந்த மாறி அமைக்கப்படாதபோது `~/.local/state/ccam/locks/`-இன் கீழ்);
4. lock-இன் கீழ், அந்தக் கணக்கின் அமர்வு இயங்கிக்கொண்டிருந்தால் மறுக்கும், மற்றொரு process ஏற்கெனவே token-ஐப் புதுப்பித்திருந்தால் கோரிக்கையைத் தவிர்க்கும்;
5. refresh token-ஐ token endpoint-க்கு அனுப்பி, புதிய tokens-ஐ `fsutil.AtomicWrite` மூலம் `.credentials.json`-இல் மீண்டும் எழுதும், கோப்பிலுள்ள மற்ற ஒவ்வொரு key-ஐயும் வைத்திருக்கும்.

### நிலை வரி சேகரிப்பான்

Claude Code நிலை வரிக் கட்டளையை இயக்கி, அதற்கு ஒரு JSON ஆவணத்தை pipe செய்கிறது. ccam அதிலிருந்து model பெயரையும் `rate_limits`-ஐயும் படிக்கிறது:

1. `runStatusline` கணக்கை `CCAM_PROFILE`-இலிருந்து கண்டுபிடிக்கிறது, இதை ccam Claude Code-ஐத் தொடங்கும்போது அமைக்கிறது; இல்லையென்றால் `CLAUDE_CONFIG_DIR`-ஐக் கணக்குக் கோப்புறைகளுடன் ஒப்பிட்டுக் கண்டுபிடிக்கிறது.
2. `ParseStatusLine` `rate_limits.five_hour` மற்றும் `rate_limits.seven_day`-ஐப் படிக்கிறது. API key கணக்குகளுக்கோ, அமர்வின் முதல் பதிலுக்கு முன்போ JSON-இல் rate limits இருக்காது; அப்போது எதுவும் சேமிக்கப்படாது.
3. `SaveStatusLine` `~/.local/state/ccam/usage/<name>.statusline.json`-ஐ எழுதுகிறது. endpoint பதில் அளிக்காதபோது `ccam usage` அதைப் பயன்படுத்தும்.
4. ccam `[name] · model · 5h N% · 7d N%` என்று அச்சிடுகிறது. `--wrap` உடன், அது உங்கள் கட்டளையை அதே உள்ளீட்டுடன் `sh -c` மூலம் இயக்கி, அதற்குப் பதிலாக `[name]`-ஐயும் அதைத் தொடர்ந்து கட்டளையின் முதல் வரியையும் அச்சிடும்.

wrap செய்யப்பட்ட கட்டளைக்கு 2 வினாடிகள் கிடைக்கும். அதன் பிறகு அது நிறுத்தப்பட்டு, வரி கணக்கின் பெயரை மட்டும் காட்டும், அதனால் மெதுவான கட்டளை Claude Code-இன் நிலை வரியைத் தடுக்க முடியாது.

`ccam statusline install` ஒவ்வொரு கணக்கின் `settings.json`-இலும் `statusLine`-ஐ எழுதுகிறது. ஒரு கணக்கிடம் ஏற்கெனவே நிலை வரிக் கட்டளை இருந்தால், ccam அதை `--wrap '<old command>'` ஆக வைத்திருக்கும். ஒரு குழு வழியாகப் பகிரப்படும் `settings.json` அதன் இணைப்பு வழியாக ஒருமுறை மட்டுமே எழுதப்படும், அதனால் குழுவின் ஒவ்வொரு கணக்குக்கும் அது கிடைக்கும். மீண்டும் இயக்கினால், ஏற்கெனவே ccam-ஐப் பயன்படுத்தும் கோப்புகளுக்கு `(already set)` என்று அச்சிடும்.

## பாதுகாப்பும் விளிம்பு நிலைகளும்

- நீங்கள் `--refresh` கொடுக்காதவரை `ccam usage` ஒருபோதும் token கோப்பை மாற்றுவதில்லை. உள்நுழைவு காலாவதியானால், `ccam <name>` மூலம் அந்தக் கணக்கை ஒருமுறை இயக்குங்கள், Claude Code அதைப் புதுப்பிக்கும்.
- `--refresh` இயங்கும் கணக்குகள், இறக்குமதி செய்யப்பட்ட கணக்குகள், Keychain உள்நுழைவுகள் ஆகியவற்றை ஒருபோதும் தொடுவதில்லை. மறுக்கப்பட்ட புதுப்பிப்பு சேமித்த எண்களையும் காரணத்தையும் காட்டும்.
- usage endpoint பொதுவில் ஆவணப்படுத்தப்படவில்லை, மாறக்கூடும். அது மாறும்போதும் சேமித்த எண்களை நீங்கள் பார்ப்பீர்கள், `ccam doctor` வடிவ மாற்றத்தைத் தெரிவிக்கும்.
- சேமித்த எண்களும் பதிலும் இல்லாதபோது, வரிசை `lookup failed:`-ஐயும் காரணத்தையும் காட்டும், எடுத்துக்காட்டாக `--source cache` உடன் `no saved usage`.
- cache கோப்புகள் சதவீதங்களையும் மீட்டமைப்பு நேரங்களையும் மட்டுமே வைத்திருக்கும், tokens-ஐ ஒருபோதும் அல்ல.

## தொடர்புடையவை

- [பயன்பாட்டு வரம்புகளும் கணக்கு மாற்றமும்](https://ccam.dev/ta/docs/usage-limits.md)
- [அடுத்த கணக்குக்கு மாறுதல்](https://ccam.dev/ta/features/next.md)
- [பயன்பாட்டு வரம்பு வழிகாட்டி](https://ccam.dev/ta/guides/usage-limit-workflow.md)
- [கட்டளைகள்](https://ccam.dev/ta/docs/commands.md)