GitHub Community
Can i switch seamingless between cost centers and Individual user-level budget? #210786
Replies: 4 comments 7 replies
|
I'd suggest keeping separate budgets for each cost center and setting individual limits only when needed. Switching between them shouldn't reset existing usage, so the same spending history should be considered. For multiple projects, separate cost centers would make tracking easier. |
|
Ok so without the individual budget the case would be no problem, but with its tricky because of hierarchy?! Is there anyway around this policy? Because we dont want to erase the individual budget. |
|
Yeah, you can keep the individual budget and set a separate cost center budget too. The individual limit still applies, though, so having money left in the cost center won't bypass it. |
|
Configure a cost center user-level budget as the default baseline for each team or department. |
|
Yes, and the mechanics are fixed by how user-level budgets stack. Under the Bundled AI credits budget type there are three user-level budgets, and they override each other in this order:
An individual budget overrides the cost center one, which overrides the universal one. It is the first check in the evaluation sequence. So "switching" a dev means: create an individual budget to pull them out of the cost center cap, and delete it or let it expire to drop them back. Individual budgets can expire at the end of the current billing cycle or on a date you pick; on expiry the user falls back to the next budget that applies to them. You cannot change a budget's scope after creating it, so it is always create and delete, not edit. Your three questions:
Docs: Using budgets to control spending, Cost center allocation for different products, Charging business units. |
|
Ok thanks so far, great clarification. One more question, is there any option and restrictions in switching between cost centers budgets, because they are on the same"level"? Can i say now i use Git Hub Copilot for cost center A and switch in git Hub or in the ide to cost center B? Or does it require a self service? |
|
Two parts:
|
|
ok so could a self service solve this problem of switching cost centers? With the base of having no individual budgets for the devs at all. In this case switching to an individual budget is like this?: creating a new one. Giving a cost budget, using it, deleting it/expiring date. "Switching" like this to cost center budgets. Doing it again, can the self service check the remaining budget of the deleted individual budget and assign it as budget for next time creating an individual one, as "switching". Sorry quite complex, but you got it? |
|
Yes, a self-service tool can do all of that, because every step has a REST endpoint. GitHub has no switch the developer can flip themselves, so the tool runs with an enterprise owner or billing manager token:
The remaining-amount part is the one GitHub won't do for you. A budget is a cap, not a balance, so nothing carries over when it is deleted. But a budget only counts usage from the day it was created ("the budget applies only to metered usage from the date of its creation onwards"), so your plan works if the tool keeps the books:
Two limits to plan for. Usage is reported per day, so the day you switch can't be split exactly between the two budgets. And because a new budget only counts from its creation, GitHub enforces each budget on its own; the running total across switches lives only in your tool. Docs: cost centers API, budgets API, usage API, budgets and alerts. |
|
Hi Leo, Yes, this is possible with GitHub Copilot Enterprise Cloud, provided you are using usage-based billing. However, there are a few important points to understand before implementing this switching logic. 1. Can a developer switch between an individual and a cost-center budget?Yes. GitHub supports three types of user-level budgets:
The most specific budget takes priority. An individual budget overrides a cost-center budget, which overrides the universal budget. For example, suppose a developer belongs to the Engineering cost center with a $20 per-user budget. If you assign that developer an individual budget of $50, the $50 limit applies instead. To switch back to the cost-center budget, remove or expire the individual override. The cost-center budget then applies automatically, assuming the developer is still a member of that cost center. 2. What happens to usage already consumed?You should not assume that switching budgets resets the developer's usage to zero. GitHub tracks AI credit consumption for the current billing cycle. Changing which budget applies is not documented as a way to reset that consumption; the regular monthly reset occurs when the next billing cycle begins. For example, if a developer has already consumed AI credits earlier in the cycle, do not assume that changing from an individual budget to a cost-center budget gives them a completely fresh allowance. One important caveat: GitHub's public documentation explains budget precedence and cycle-based consumption, but does not explicitly detail every mid-cycle budget-switching scenario. I would verify the exact remaining-headroom behavior with GitHub Support before automating budget changes that affect production usage. Reference: https://docs.github.com/en/copilot/how-tos/manage-and-track-spending/monitor-ai-usage 3. What happens when the developer switches back to the individual budget?When an individual budget is created or restored, it takes precedence over the cost-center and universal budgets. However, it should not be treated as a new, independent allowance that automatically starts from zero. The developer's usage is tracked for the billing cycle. A practical implementation would be:
For temporary individual budgets, GitHub also supports expiration dates. When the individual budget expires, the developer falls back to the cost-center budget, or the universal budget if no cost-center budget applies. 4. What happens when a developer works across multiple projects?This is where an important restriction arises. GitHub Copilot's AI credit budgets are based on users, cost centers, organizations, and enterprises—not on individual projects or repositories for user-level budget enforcement. For example, suppose one developer works on three projects:
The developer's usage across these projects is not automatically separated into three independent user-level budgets merely because the work belongs to different projects. If you need project-oriented cost tracking, you should establish an appropriate cost-center structure and verify how usage is attributed. Under GitHub's documented allocation rules, Copilot AI credit usage is generally attributed according to the user who triggered it, or the organization that granted the license when no direct user assignment applies. A developer's effective cost-center assignment also follows GitHub's allocation rules. For example, a direct assignment takes precedence over an assignment inherited from an enterprise team. Reference: https://docs.github.com/en/billing/reference/cost-center-allocation 5. What is the recommended implementation?I would recommend the following setup:
Also, be careful not to confuse a cost-center user-level budget with a cost-center spending budget. The former limits each member's AI credit consumption; the latter limits the cost center's total metered spending after the shared AI credit pool is exhausted. These controls can be used together. ConclusionSwitching between individual and cost-center user-level budgets is supported, but the switch should be treated as a change in the applicable spending limit—not as a new billing cycle or a reset of usage. For developers working across multiple projects, remember that user-level Copilot budgets do not independently allocate each developer's AI consumption to separate projects. Official documentation: I would appreciate hearing from anyone who has tested mid-cycle switches in a production GitHub Enterprise Cloud environment, particularly whether the effective remaining allowance is recalculated immediately when the budget scope changes. |
Uh oh!
There was an error while loading. Please reload this page.
🏷️ Discussion Type
Question
Body
For better tracking, we want to create a logic where a dev can switch between individual user-level budget and cost center user-level budget. Is that possible with copilot git hub or are there restrictions? Detailed questions:
What happens to ongoing expenses? Does the user start over at 0? What happens if they switch back to the personal budget?
And what about when there are multiple projects?
(Enterprise Cloud solution)
Just ask for further questions, if needed for context/solution.
Thanks in advance.
Leo
All reactions