# GitHub Copilot CLI cost tracking: /usage, credits, budgets

Copilot CLI's /usage shows per-model tokens and AI credits (1 credit = $0.01). Where usage lives, what admins see, what is missing, how to cap it.

GitHub Copilot CLI does show what a session uses: `/usage` prints per-model token totals, and on token-based billing each model's row also shows the AI credits it consumed. One AI credit is $0.01, so that figure converts straight to dollars. What it does not give you is cost per tool call, cost per repository, or a running total across sessions on your machine.



This page covers the terminal agent you start with `copilot`: how it is billed, what the CLI shows, where an admin sees usage, what is missing, and how to cap it. For what the CLI may run, see the [Copilot CLI permissions and hooks reference](/blog/github-copilot-cli-permissions-and-hooks-reference).

## How Copilot CLI is billed

Two systems exist, and which one applies depends on your plan.

**AI credits (the default since June 1, 2026, per GitHub's [legacy requests page](https://docs.github.com/en/copilot/concepts/billing-and-usage/copilot-requests), which keeps annual Pro and Pro+ subscribers on request billing past that date).** GitHub's [individual billing page](https://docs.github.com/en/copilot/concepts/billing-and-usage/individuals/billing) lists Copilot CLI among the features that consume AI credits, alongside Copilot Chat, the cloud agent, Spaces, Spark and third-party coding agents. Each request is priced from three token types, input, output and cached, at the rate for the model used, and "this total is converted into AI credits (1 AI credit = $0.01 USD)." Code completions and next edit suggestions are not billed in credits.

Monthly allowances for individual plans, from the same page:

| Plan | Price | Base credits | Flex allotment | Total |
|---|---|---|---|---|
| Pro | $10/month | 1,000 | 500 | 1,500 |
| Pro+ | $39/month | 3,900 | 3,100 | 7,000 |
| Max | $100/month | 10,000 | 10,000 | 20,000 |

Base credits are used first. Credits do not roll over; the allowance resets at 00:00:00 UTC on the first of each month. Copilot Free and Student get an allowance too, with models through auto selection only; GitHub does not publish the number on that page. For Business and Enterprise, each license comes with included credits pooled at the billing entity level, per the [budgets page](https://docs.github.com/en/copilot/concepts/billing-and-usage/organizations-and-enterprises/budgets): 1,900 per Business license and 3,900 per Enterprise license.

Per-token rates live on GitHub's [models and pricing reference](https://docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing), in USD per million tokens. One row as an example:

| Model | Input | Cached input | Output |
|---|---|---|---|
| Claude Sonnet 4.6 | $3.00 | $0.30 | $15.00 |

**Premium requests (legacy).** Pro and Pro+ users on annual plans stay on request-based billing until the plan expires, per GitHub's [legacy requests page](https://docs.github.com/en/copilot/reference/copilot-billing/request-based-billing-legacy/copilot-requests). There, "each prompt to Copilot CLI uses one premium request with the default model," and other models multiply that by their rate. Only prompts you send count; tool calls the agent makes on its own do not. Legacy allowances are 300 a month on Pro and 1,500 on Pro+, with extra requests at $0.04 each.

The difference: under premium requests a long agent turn cost one request whatever it did. Under AI credits it costs the tokens it used. An agent that re-reads a large context on every one of twenty tool calls pays for that context each time.

## What the CLI shows

GitHub's [CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference) documents these:

```text
/usage      Display session usage metrics and statistics, including per-model token totals.
            For token-based-billing accounts, each model's row also shows its own
            AI credit consumption (for example, 1 AIC).
/context    Show the context window token usage and visualization.
/compact    Summarize the conversation history to reduce context window usage.
/model      Select the AI model you want to use, or choose Auto.
/limits     Open the interactive response limits dialog.
```

The reference adds that billed models with no token counts show credits only.

In print mode, `-s` (`--silent`) outputs "only the agent response (without usage statistics)", which tells you the default `-p` output includes usage statistics after the response.

```bash
copilot -p "summarize the open TODOs in src/"        # response, then usage statistics
copilot -p "summarize the open TODOs in src/" -s     # response only
```

Model choice is the biggest lever on the number `/usage` shows. `/model` sets the model, reasoning effort or context window for the current session; `--global` sets it for future sessions. `/model auto` picks Auto, and the individual billing page lists a 10% discount on model costs with auto model selection in Chat or the cloud agent.

## Where the numbers live

**In the session.** `/usage` is per session. The CLI keeps user settings and state under `~/.copilot` (or `$COPILOT_HOME`) and writes logs to `~/.copilot/logs/` by default, per the command reference. GitHub does not document a usage file you can parse, so treat `/usage` as the per-session view.

**On your account.** The [usage dashboard](https://docs.github.com/en/billing/how-tos/products/view-productlicense-use) at `github.com/settings/billing` shows your allowance and what you have used. Accounts on AI credits get an extra **AI usage** view under **Usage**. From there, **Get usage report** emails you a download link that expires after 24 hours.

**In the organization.** Under **Billing & Licensing**, the same **AI usage** view applies at org and enterprise scope. Enterprise owners and billing managers can filter AI usage by user; org owners cannot see user-level data in the view and have to download the report.

## How teams see it

The usage metrics API is where Copilot CLI shows up per user. GitHub's [metrics data reference](https://docs.github.com/en/copilot/reference/copilot-usage-metrics/copilot-usage-metrics) documents a `totals_by_cli` object in per-user daily reports:

```text
totals_by_cli.session_count                       distinct CLI sessions that day
totals_by_cli.request_count                       requests, including agentic follow-up calls
totals_by_cli.prompt_count                        user prompts in a session
totals_by_cli.token_usage.prompt_tokens_sum       prompt tokens across CLI requests
totals_by_cli.token_usage.output_tokens_sum       output tokens across CLI requests
totals_by_cli.token_usage.avg_tokens_per_request  (output + prompt) / request_count
ai_credits_used                                   credits for the user, all surfaces
```

Aggregated reports add `daily_active_cli_users`. The [REST endpoints](https://docs.github.com/en/rest/copilot/copilot-usage-metrics) return download links to NDJSON report files, for example:

```bash
gh api /orgs/YOUR_ORG/copilot/metrics/reports/users-28-day/latest
```

The "Copilot usage metrics" policy has to be enabled for the endpoints to work.

Three caveats from GitHub's own reference. CLI usage is counted separately from IDE metrics and is not in `totals_by_ide` or `totals_by_feature`. The metrics dashboard does not include Copilot CLI usage at all, so the API is the only per-user CLI view. And `ai_credits_used` "is for consumption analysis, not invoicing totals" and is not broken down by feature, model or surface.

## What is not shown

- **Cost per call or per tool call.** `/usage` totals by model for the session. Nothing documented shows which tool call or which turn spent the credits.
- **Cost per repository.** The metrics API has repository-level pull request activity, but `totals_by_cli` is per user per day. GitHub also notes organization metrics follow membership, not where the work happened.
- **CLI credits on their own.** `ai_credits_used` mixes every surface. To estimate CLI dollars you multiply `totals_by_cli` token sums by model rates yourself, and the CLI block does not split by model or report cached tokens.
- **Same-day totals for admins.** API reports are daily records; the dashboard is a 28-day rolling window without CLI.

## How to put a budget on it

**Per response, in the CLI.** A soft cap that resets with every user message:

```bash
copilot --max-ai-credits=50
```

Or mid-session:

```text
/limits set max-ai-credits 50
/limits unset max-ai-credits
```

For long autonomous runs, `/goal` and `/autopilot` accept `--max-ai-credits N`; when the cap is reached, autopilot pauses and opens a panel reporting credits used against the cap.

**Per account.** Individuals set a budget for additional usage once the allowance runs out; the billing page notes "a $10 budget covers 1,000 AI credits," and that additional usage may be capped.

**Per user, in an organization.** From the [budgets page](https://docs.github.com/en/copilot/concepts/billing-and-usage/organizations-and-enterprises/budgets):

- A **user-level budget** caps one user's credits in a billing cycle and "always enforce[s] a hard stop." A $0 user-level budget blocks credit-consuming features immediately. Universal, cost-center and individual budgets exist; the most specific one wins.
- **Organization, cost center and enterprise budgets** limit metered charges, but stop usage only if "Stop usage when budget limit is reached" is enabled, which is off by default.
- Once the included pool is empty, usage is metered only if the **AI credits paid usage** policy is enabled; otherwise it is blocked. Completions keep working when a user is blocked.

## What the billing views leave out

Everything above counts model usage. None of it says what the agent did with it: which commands ran, which files changed, which call was blocked. Copilot CLI's hooks see those tool calls but not tokens. The billing views see tokens but not tool calls.

ACP's Copilot hook covers the tool-call side. It checks and logs shell, file-edit and MCP calls, and holds risky ones for your approval on the console or by email. The [Copilot controls page](/controls/copilot) has the details. We have not verified that ACP can read Copilot's token or credit numbers, so keep using the GitHub views above for cost.

## Frequently asked questions



## Where to read more

- [Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference) for `/usage`, `/limits` and `--max-ai-credits`
- [Copilot billing for individuals](https://docs.github.com/en/copilot/concepts/billing-and-usage/individuals/billing) for allowances, token pricing and running out
- [Models and pricing](https://docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing) for per-token rates by model
- [Budgets for usage-based billing](https://docs.github.com/en/copilot/concepts/billing-and-usage/organizations-and-enterprises/budgets) for user, org, cost center and enterprise budgets
- [Data available in Copilot usage metrics](https://docs.github.com/en/copilot/reference/copilot-usage-metrics/copilot-usage-metrics) for `totals_by_cli` and `ai_credits_used`
- [Copilot CLI permissions and hooks reference](/blog/github-copilot-cli-permissions-and-hooks-reference) for what the CLI may run