Managing Your GitHub Copilot Business Usage

The Shared AI Credit Pool

Each user with access to a GitHub Copilot Business seat through Northwestern contributes 1,900 AI credits (equivalent to $19) at the beginning of each month to a common credit pool that is shared across all Northwestern users with a GitHub Copilot Business license. All Northwestern users of GitHub Copilot Business draw from this single shared pool. Once this shared pool of credits is depleted, any additional usage of GitHub Copilot is billed to the Azure subscription associated with your GitHub organization until the pool is refilled at the beginning of the next month. Additional usage is billed for all users, no matter whether they've already used the 1,900 credits their seat contributed to the pool or not. Read more about the shared AI credit pool and metered AI usage here.

To ensure fair access to this shared credit pool, AI credit usage is capped at 15,000 credits (equivalent to $150) per user per month as of September 2026. This ensures outsize usage by a small number of users does not empty the shared pool and less than 10% users are expected to be affected by this limit. For users who hit this limit, all usage of GitHub Copilot will effectively be stopped until the next month begins.

Below is information on managing your usage and alternative methods for working with GitHub Copilot if you hit your usage limit.

Check your usage

You can see your own current usage and your monthly cap at any time on GitHub: github.com/settings/copilot/features

Under "Usage," you will see how many AI credits you have used this billing cycle out of the monthly limit.

A few IDEs also show usage without leaving your editor:

• VS Code: click the Copilot icon in the status bar
• JetBrains IDEs: click the Copilot icon in the status bar, then "View quota usage"
• Visual Studio: click the Copilot icon, then "Copilot Consumptions"
• Xcode: click the Copilot icon in the menu bar
• Eclipse: click the Copilot icon in the status bar

Copilot credit billing

Inline code completions are free

Inline code completions and next-edit suggestions (the gray "ghost text" as you type) in IDEs are not billed in credits and are unlimited on any paid Copilot plan. Credits are consumed by:

• Copilot Chat (in your IDE, in the CLI, or on github.com)
• Agent mode and the Copilot coding agent
• Copilot CLI sessions
• Copilot code review (which also use GitHub Actions minutes)

Model choice

Different models cost very different amounts per token. You can see current per-token pricing at docs.github.com/en/enterprise-cloud@latest/copilot/reference/copilot-billing/models-and-pricing. As a rough guide, the "Powerful" category models (Claude Opus variants, GPT-5.5, Gemini 3.1 Pro, and similar) cost 3-10x more per token than "Versatile" or "Lightweight" models. Running everything through a Powerful model as your default is the single fastest way to burn through the shared pool.

Reduce your usage

Watch which model you're using

Use Auto model selection for most day-to-day chat and agent work. Auto routes each request to a model suited to the task's complexity and to current system load, and it also comes with a 10% discount on model costs compared to picking a specific model yourself. For most questions and routine coding tasks, Auto will not reach for an expensive model unless the task actually warrants it.

Reserve Powerful models for tasks that truly need them. If you are deliberately picking a specific model instead of using Auto, save the expensive ones (Opus-class models, GPT-5.5, etc.) for hard reasoning tasks, large refactors, or cases where a Lightweight or Versatile model already got something wrong. Don't set a Powerful model as your default for everyday chat.

Be deliberate with agent mode and the CLI

Agent sessions can rack up many chat turns and tool calls in the background, each consuming tokens. Give the agent clear, well-scoped tasks rather than open-ended ones, and check in on long-running sessions rather than letting them iterate indefinitely. Copilot CLI also lets you set a session credit limit so a single session cannot run away with your budget; see Set an AI credit limit in GitHub's Copilot CLI documentation.

Be aware of automatic code review

If your organization or repository has Copilot set to automatically review pull requests, every review consumes credits (billed to whoever requested it, or to the PR author if a policy triggered it automatically). If you don't need a review on every single PR, request it manually only when useful rather than relying on automatic triggers.

Alternative: bring your own key (BYOK)

If you are running up against the monthly usage cap, you can point Copilot at a model you deploy through Azure. This is called "bring your own key" (BYOK), referring to a model API key. Usage through BYOK is billed to the Azure subscription associated with your GitHub organization, not to Northwestern's shared GitHub Copilot credit pool, so it does not count against your monthly cap.

OpenAI models deployed through Azure's Microsoft Foundry have the same overall data security guidance as GitHub Copilot, as do other generative AI models offered directly by Azure. BYOK is also available for models deployed locally through applications such as Ollama or through other API providers, but the data security protections provided by other APIs may not match what is available through GitHub Copilot Business and Azure OpenAI model deployments.

All GitHub organizations with Copilot seats enabled also have an associated Microsoft Azure subscription for billing. If you need access to your Azure subscription, talk to your GitHub organization manager for details. You do not have to use the same Azure subscription associated with your GitHub organization for BYOK, but you do need one managed through Northwestern in order for the University data protections to apply.

BYOK is not available for use with GitHub Actions or other GitHub Copilot activity on the GitHub platform/website. If you need to use GitHub Copilot on the GitHub platform, make sure to switch to BYOK before you hit your monthly usage cap in order to preserve capacity for those activities.

Step 1: Deploy a model

Deploy an appropriate model through Azure's Microsoft Foundry. You will need the resource endpoint (a URL), deployment name, and API key. A tutorial on deploying models through Microsoft Foundry is available in the Research Computing and Data Services documentation. There may also be options to manage access to models through a Microsoft Entra ID.

Step 2: Connect it to Copilot

Setting up BYOK depends on how you're using GitHub Copilot:

VS Code: See the VS Code BYOK Documentation to open the model settings and choose to add an Azure model. You will be asked for the API key, and then you will need to fill in a JSON template with information about your model deployment. * For the "id" field, enter the deployment name exactly as it appears in the Azure portal. Unless you changed it, this will be the model name, such as "gpt-5.5". * For the "name" field, enter the value you want to appear in the list of models that Copilot shows you to pick from. This can be any value you want. * For the "url" field, the endpoint URL should be the URL specifically for OpenAI. It looks like: https://<resource-name>.openai.azure.com/, where <resource-name> is replaced with the name you chose when setting up the Microsoft Foundry resource. This URL will be different for models from other providers. * Leave the other fields with their default values.

You may need to add some additional values to the JSON setup to make it work. For example, for a GPT 5.5 model deployment via Azure, add "thinking": true to prevent GitHub Copilot from adding an invalid temperature parameter to the request:

[
    {
        "name": "Azure",
        "vendor": "azure",
        "apiKey": "${input:chat.lm.secret.-<id-number>}",
        "models": [
            {
                "id": "gpt-5.5",
                "name": "my gpt-5.5",
                "url": "https://<resource-name>.openai.azure.com/",
                "toolCalling": true,
                "vision": true,
                "thinking": true,
                "maxInputTokens": 128000,
                "maxOutputTokens": 16000,
            }
        ]
    }
]
 

After you add your Azure-based model, you may need to close the GitHub Copilot chat session/window and open a new one before you're able to select the newly added model.

GitHub Copilot CLI: See GitHub's instructions for setting environment variables before starting the Copilot application. Use the format of the base URL for Azure OpenAI resources as described in the GitHub documentation: https://YOUR-RESOURCE-NAME.openai.azure.com/openai/deployments/YOUR-DEPLOYMENT-NAME.

Other IDEs: To set up BYOK for other IDEs, look for similar settings in the GitHub Copilot plugin or window. JetBrains currently supports BYOK, but not all IDEs support BYOK directly.

Step 3: Monitor usage

BYOK billing goes straight to your Azure subscription. Keep an eye on your Azure spend the same way you would watch Copilot credits. There is no shared-pool cap protecting you here; it is a direct pay-as-you-go cost against your own resource. You can see your usage of the model from the Monitoring section of the Microsoft Foundry portal page, under the Resource Usage tab. You can use Kion to set up spending alerts for your Azure account. Note, however, that these are just alerts and not hard limits; Kion will not stop your usage if it goes beyond the set budget.

Questions

If you are a researcher, Research Computing and Data Services can help you setup GitHub Copilot BYOK or answer questions about GitHub Copilot usage. Request a consultation.

If you are an administrative user, email servicedesk@northwestern.edu to request help with GitHub Copilot Business.