4 Ways to Calculate Annual Cost for GitHub

If you’re responsible for GitHub billing, estimating annual cost can feel messy. Pricing mixes seat-based plans, organization features, and usage-based services like Actions minutes and package storage.

This article shows four ways to calculate yearly spend so you can compare tiers and scenarios with confidence. You’ll learn how to break costs into components, annualize usage, and model per-seat versus usage billing to pick the right plan.

Table of Contents

• Use Github's UI
• Use Torii
• Use Github's API
• Use Claude (via MCP)

Use Github’s UI

Here, you’ll use the GitHub web UI to find how much you pay in a year, either by locating a single annual invoice or by exporting and adding up monthly invoices.

Open your organization’s settings

• Click your profile photo in the top-right.
• Click Your organizations and pick the org you want.
• On the organization page, click Settings.

Go to Billing and plans

• In Settings, find and click Billing and plans in the left sidebar.
• The Billing page shows an overview with estimated charges, plan details, and billing frequency.

Check for an annual invoice or plan summary

• On the Billing page look for:
  • Your plan name and whether it is billed monthly or yearly.
  • A current invoice section. If you are on an annual plan you will usually see a single invoice for the year and the total amount billed.
  • If an annual invoice is present, open or download that invoice to confirm the billed amount for the year.

Use invoices if you’re billed monthly

• If you are billed monthly, open Invoices or Billing history from the Billing page.
• For each month in the past 12 months:
  • Open the invoice.
  • Download the PDF or note the total amount.
  • Add the 12 monthly totals to get your annual cost.

Export usage and charges to speed the math

• On the Billing page look for a Download or Export option for usage or charges.
• Export the CSV for the 12-month range you need.
• Open the CSV in a spreadsheet and sum the total-charge column to get the annual amount.

Watch for extra charge types

• When you add invoices, include:
  • Per-seat license charges.
  • Usage charges (Actions, Packages, etc).
  • Any one-time or prorated fees.
  • If you see credits or refunds on invoices, subtract them from the total.

Quick checks after you calculate

• Verify billing frequency shown on the Billing page matches what you used (monthly vs yearly).
• If you see unexpected charges, download the relevant invoice PDFs and match line items to usage exports before contacting support.

GitHub’s documentation on organization billing covers these UI pages and how to download invoices and usage exports if you need more detail.

Use Torii

Rather than pulling numbers from GitHub itself, you can use Torii, a SaaS Management Platform, to surface your GitHub annual cost. SMPs collect all your SaaS subscriptions in one place, giving you a single source of truth for spending across tools.

To determine your GitHub annual cost via Torii, do the following:

1. Sign up for Torii

Contact Torii to request a complimentary two-week proof-of-concept.

2. Connect your expense accounts & contracts to Torii

After your Torii workspace is provisioned, link your finance systems - for example Coupa or QuickBooks - so Torii can import billing data and attribute the cost of your GitHub subscription.

You can also upload contract documents directly into Torii; their AI will extract pricing and renewal details automatically.

Here are more instructions for the Github integration.

3. Search for Github within Torii

Type “Github” into the Torii dashboard search bar to open the GitHub entry. There you’ll find license counts, total spend, renewal dates, and other account-level cost details.

Or, chat with Eko

Torii’s AI assistant, Eko, can also pull up GitHub details inside Torii through natural-language chat. Just select the Eko icon in the lower-right corner of the dashboard and ask it to locate GitHub information - it will display the results directly in the chat window.

Use Github’s API

Here you’ll call GitHub’s billing endpoints and use their returned estimates to build an annual figure.

Pick the right billing endpoints for your scope

• GitHub exposes billing endpoints for users, organizations, and enterprises. Choose the endpoint that matches where the costs are incurred:
  • User-level (if billing is on a personal account): use the user billing endpoints.
  • Organization-level: use the org billing endpoints for Actions, Packages, and shared storage.
  • Enterprise-level: use the enterprise billing endpoints if your account is billed at the enterprise level.
  • Typical REST paths you’ll find in GitHub’s API docs:
  • Organization Actions billing: GET /orgs/{org}/settings/billing/actions
  • Organization Packages billing: GET /orgs/{org}/settings/billing/packages
  • Organization shared storage billing: GET /orgs/{org}/settings/billing/shared-storage
  • Equivalent user or enterprise paths exist in the docs; pick the matching path for your account.

Ensure you have a token and permissions

• Use a personal access token or app token that has the rights to read billing for the chosen scope. You usually need org/enterprise admin or billing access.
• Export the token into an environment variable so calls are easy to run:

export GITHUB_TOKEN="ghp_xxx."

Pull the current-month estimates from each billing endpoint

Example curl is:

curl -s -H "Authorization: token $GITHUB_TOKEN" \
https://api.github.com/orgs/ORGANIZATION/settings/billing/actions

• Repeat for packages and shared-storage (or the user/enterprise equivalents).
• Each endpoint returns JSON with usage and estimated charge fields. Inspect the JSON to find numeric keys that indicate an estimated cost or charges for that product.

Extract the estimated monthly costs from each response

Look for keys that include words like estimated, cost, or charges. Field names vary by endpoint; the docs show the exact response schema.

Example: pull numeric fields with a short jq expression (adjust the key tests if your responses use different names):

ACTIONS_JSON=$(curl -s -H "Authorization: token $GITHUB_TOKEN" https://api.github.com/orgs/ORGANIZATION/settings/billing/actions)
PACKAGES_JSON=$(curl -s -H "Authorization: token $GITHUB_TOKEN" https://api.github.com/orgs/ORGANIZATION/settings/billing/packages)
STORAGE_JSON=$(curl -s -H "Authorization: token $GITHUB_TOKEN" https://api.github.com/orgs/ORGANIZATION/settings/billing/shared-storage)
ACTIONS_COST=$(echo "$ACTIONS_JSON"  jq '[to_entries[]  select(.keytest("estimatedcostcharge"))  .value]  add // 0')
PACKAGES_COST=$(echo "$PACKAGES_JSON"  jq '[to_entries[]  select(.keytest("estimatedcostcharge"))  .value]  add // 0')
STORAGE_COST=$(echo "$STORAGE_JSON"  jq '[to_entries[]  select(.keytest("estimatedcostcharge"))  .value]  add // 0')

Those jq filters sum any top-level numeric fields whose keys match estimated, cost, or charge. If the API nests cost fields, inspect the JSON and adjust the jq path.

Combine monthly estimates and project to a year

Sum the monthly estimates and multiply by 12 to get a simple annual projection.

MONTHLY_TOTAL_CENTS=$(echo "$ACTIONS_COST + $PACKAGES_COST + $STORAGE_COST"  bc)

# If the values are in cents, convert to dollars:
MONTHLY_TOTAL_DOLLARS=$(echo "scale=2; $MONTHLY_TOTAL_CENTS/100"  bc)
ANNUAL_DOLLARS=$(echo "scale=2; ($MONTHLY_TOTAL_CENTS * 12)/100"  bc)
printf "Monthly estimate: $%s\n" "$MONTHLY_TOTAL_DOLLARS"
printf "Annual estimate: $%s\n" "$ANNUAL_DOLLARS"

If the API returns dollars rather than cents, skip the cents-to-dollars conversion and multiply directly.

Check nuances and improve accuracy

• The API returns month-to-date estimates. If your usage varies a lot, multiply by 12 is a simple projection. For better accuracy:
  • Pull the same endpoints each month and average real monthly totals.
  • Cross-check with invoices or billing reports the API exposes for historical charges (see the billing docs for invoice endpoints).
  • Always verify the exact response fields in the GitHub API docs for your endpoint before scripting so your jq paths match.

Summary

Call the billing endpoints for your account scope, extract the estimated monthly charges from each product (Actions, Packages, storage), sum them, and multiply by 12 for an annual projection. Adjust parsing based on the exact JSON fields shown in GitHub’s API docs for each endpoint.

Use Claude (via MCP)

You can also retrieve this information directly from Claude using the Model Context Protocol (MCP). Claude is Anthropic’s AI assistant and an alternative to ChatGPT.

To get your annual cost from GitHub via Claude, complete these steps:

1. Set up Torii

Follow the Torii setup steps above to link your GitHub account with Torii: https://www.toriihq.com/.

After connecting, generate a new API key in Torii’s Settings.

2. Set up MCP in Claude

See the Torii MCP docs here: https://www.npmjs.com/package/@toriihq/torii-mcp?activeTab=readme and this explanatory post: https://www.toriihq.com/blog/introducing-model-context-protocol-in-torii.

Install the Claude Desktop application, then add the following entry to your claude_desktop_config.json:

{
    "mcpServers": {
        "Torii MCP": {
            "command": "env",
            "args": [
                "TORII_API_KEY=YOUR_API_KEY",
                "npx",
                "@toriihq/torii-mcp"
            ]
        }
    }
}

Remember to replace YOUR_API_KEY with the key you created in Torii Settings.

3. Chat with Claude

Once configured, you can query your Torii data from within Claude. For example, ask it to examine your GitHub account and report license counts, total spend, upcoming renewal dates, and similar billing details.