TL;DR (June 2026): Since June 1, 2026, GitHub Copilot bills in AI Credits (1 credit = $0.01), metered by token usage. On June 19, GitHub added an ai_credits_used field to the Copilot usage metrics REST API, so you can finally pull per-user credit consumption programmatically. The catch: it is a per-user daily total only - not broken down by model, feature, or surface. If you need to know which model or which project burned the credits, the API will not tell you, and that gap is what the community is loudly asking GitHub to fix.
What changed: PRUs out, AI Credits in
On June 1, 2026, GitHub retired the old Premium Request Unit (PRU) model and switched Copilot to usage-based billing denominated in AI Credits. The math is simple on the surface: 1 AI Credit = $0.01, so a $10 monthly budget is 1,000 credits. Underneath, every interaction consumes tokens (input, output, and cached context) priced at the underlying model's API rate and converted into credits. Plan prices did not change (Pro $10, Pro+ $39, Business $19/user) - what changed is that you now burn a metered balance on top of the seat.
The new tracking surface: the usage metrics API
GitHub shipped the reporting endpoints alongside the billing change, and then closed an obvious gap on June 19 by adding ai_credits_used to the Copilot usage metrics API. What you can pull today:
- Per-user daily credit consumption via the Copilot usage metrics API - the new
ai_credits_usedfield shows how many credits each developer consumed per day. - Organization and user AI-credit usage reports via the billing usage REST endpoints (e.g. the AI credit usage report under settings/billing), covering included-pool consumption and additional usage spend. Historical data goes back up to 24 months.
- Usage-summary first, detail second - GitHub's own guidance is to start with a usage summary for overall spend, then pull AI-credit usage data when you need deeper Copilot insight.
For an org admin who just needs "how many dollars did each seat burn," this is enough to automate a weekly report and catch the outliers.
What the API still hides
Here is the part the changelog is quiet about. ai_credits_used is an overall per-user total. It is not broken down by feature, model, or surface. So you can see that a developer spent 4,200 credits last week, but not:
- Which model ate them (was it cheap completions or an expensive agent model?).
- Which feature or surface (chat vs agent mode vs code review).
- Which project or repo the spend belongs to - so you cannot attribute Copilot cost to a cost-center or a client.
The community noticed immediately. models.dev issue #1931 asks for per-model cost fields so developers can see "the actual costs they are making in their sessions," and the steipete/CodexBar tracker has open work to surface AI Credits beyond the quota window. The demand is clear: a per-user total is a start, but real cost management needs attribution.
How to actually attribute Copilot AI-Credit spend
Until GitHub breaks the field down, you have three options:
- Local session parsing. Tools that read on-disk session files can infer per-model and per-project spend for a single developer. Good for one laptop, not for a team.
- Poll the API and segment yourself. Pull
ai_credits_usedper user daily, then cross-reference with what you know about each developer's work. Crude, and it falls apart when one person works across many projects. - Run a usage-metering layer. Capture the spend with proper dimensions (model, project, customer, cost-center) at the point of use, so attribution is structural rather than reconstructed after the fact.
Where UsageBox fits: GitHub's API answers "how many credits did this user burn." UsageBox answers the questions it can't - per-model, per-project, and per-customer cost attribution, real-time spend caps before an overrun lands, and turning that metered AI spend into billing. Pull the GitHub totals for the headline number; meter with dimensions when you need to know who actually owes what.
The takeaway
AI Credits made Copilot spend real, and the June 19 API update made it finally trackable - but only at the per-user-total altitude. The honest 2026 picture: you can now see that a developer spent, automate a report, and catch outliers, but you cannot yet see where the credits went from GitHub alone. If your only question is "is anyone burning way too much," the API is enough. If you need to attribute Copilot cost to a project, model, or client, plan for a metering layer on top.