Using the GitHub REST API to Track Repository Costs by Cost Center

using System.Net.Http.Headers;
using System.Text.Json;

public sealed class GitHubBillingClient
{
    private readonly HttpClient _httpClient;

    public GitHubBillingClient(string token)
    {
        _httpClient = new HttpClient
        {
            BaseAddress = new Uri("https://api.github.com/")
        };

        _httpClient.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Bearer", token);

        _httpClient.DefaultRequestHeaders.Accept.Add(
            new MediaTypeWithQualityHeaderValue(
                "application/vnd.github+json"));

        _httpClient.DefaultRequestHeaders.Add(
            "X-GitHub-Api-Version", "2026-03-10");

        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(
            "RepositoryCostReporter");
    }

    public async Task<JsonDocument> GetRepositoryMembershipAsync(
        string enterprise,
        string repository)
    {
        var query =
            $"resource_type=repository&name={Uri.EscapeDataString(repository)}";

        var endpoint =
            $"enterprises/{Uri.EscapeDataString(enterprise)}" +
            $"/settings/billing/cost-centers/memberships?{query}";

        using var response =
            await _httpClient.GetAsync(endpoint);

        response.EnsureSuccessStatusCode();

        var content = await response.Content.ReadAsStringAsync();

        return JsonDocument.Parse(content);
    }
}

The example uses JsonDocument so the application can inspect the response without requiring a model for every field. In a larger application, strongly typed response models are usually easier to maintain.

Retrieve Usage for a Cost Center

Once the application has a cost center ID, it can request the usage summary for a reporting period.

For example, this request retrieves enterprise usage for a particular cost center during November 2026:

GET /enterprises/{enterprise}/settings/billing/usage/summary?year=2026&month=11&cost_center_id={cost_center_id}

The response contains a usageItems collection. Each item can include fields such as:

• product: the GitHub product associated with the usage.
• sku: the specific billed SKU.
• unitType: the unit used for measurement.
• pricePerUnit: the price for one unit.
• grossQuantity: the quantity before discounts.
• grossAmount: the amount before discounts.
• discountAmount: the discount applied.
• netQuantity: the quantity after applicable adjustments.
• netAmount: the resulting amount.

For financial reporting, netAmount is generally the more useful field when presenting the amount after discounts. Keep the gross and discount values as well if finance needs to reconcile the figures.

A .NET method can retrieve the summary:

public async Task<JsonDocument> GetUsageSummaryAsync(
    string enterprise,
    string costCenterId,
    int year,
    int month)
{
    var query =
        $"year={year}&month={month}" +
        $"&cost_center_id={Uri.EscapeDataString(costCenterId)}";

    var endpoint =
        $"enterprises/{Uri.EscapeDataString(enterprise)}" +
        $"/settings/billing/usage/summary?{query}";

    using var response =
        await _httpClient.GetAsync(endpoint);

    response.EnsureSuccessStatusCode();

    var content = await response.Content.ReadAsStringAsync();

    return JsonDocument.Parse(content);
}

The reporting application can then read the usage items and store them in its own database.

The enterprise usage summary endpoint supports a maximum historical window of 24 months. Plan the reporting process accordingly rather than expecting the API to provide unlimited historical billing data.

Build a Repository Cost Report

A useful reporting pipeline combines repository membership with billing usage.

For example, a scheduled job can perform the following operations:

1. Retrieve the active cost centers for the enterprise.
2. Identify the repositories assigned to each cost center.
3. Retrieve usage summaries for the required reporting period.
4. Store product, SKU, quantity, and amount information.
5. Generate a report grouped by cost center and product.

A simple reporting table might look like this:

These values are illustrative, not actual GitHub prices or usage figures.

For finance reporting, store the billing period, cost center ID, repository identifier where available, product, SKU, and synchronization timestamp. Use the cost center ID as the stable relationship key instead of relying only on its display name, which administrators can change.

One limitation needs careful handling: the enterprise usage summary is an aggregated billing report. It should not automatically be treated as a repository-by-repository cost breakdown. Use the repository filter where the endpoint supports it, or combine the available repository-level information with cost center membership. Do not divide a cost center's total across repositories unless the organization has agreed on an allocation method.

Keep the Numbers Reliable

Billing reports need more care than ordinary operational dashboards. A missing API response or a changed cost center assignment can make a report misleading.

A few implementation decisions help avoid common problems:

• Store the cost center ID alongside its name so that renaming does not break historical joins.
• Record the year and month used in every usage request.
• Keep gross amount, discount amount, and net amount rather than storing only one total.
• Treat an empty membership result as unassigned, not as zero cost.
• Record failed synchronization jobs instead of replacing missing data with zero.
• Reconcile periodic totals with GitHub's billing interface and invoices.
• Use bounded retries for temporary server failures, but do not repeatedly retry authentication and permission errors.
• Keep historical snapshots so that a repository's reassignment does not rewrite earlier reporting periods.

Also pay attention to resource allocation. A repository can be reassigned to another cost center, and that change affects where its usage is charged. A report should make the reporting period clear and should not use today's membership as proof of ownership for every previous month.

Common Problems

Conclusion

The GitHub REST API provides the building blocks for automated repository cost reporting. The usage summary endpoint supplies billing information, the cost center endpoint provides enterprise allocation details, and the membership lookup endpoint connects a repository to its assigned cost center.

The most important part is combining these resources without confusing membership with actual usage. Preserve stable identifiers, retain the billing period, and make the allocation rules clear to anyone reading the report.

With a scheduled .NET integration and a reporting database, engineering and finance teams can track GitHub spending by business unit, investigate changes in usage, and prepare more consistent cost reports.