| 1 | --- |
| 2 | title: Usage and billing |
| 3 | description: What is free on g1t, what the g1t plan costs and includes, how compute is paid for, the limits that keep spend in check, and enterprise billing. |
| 4 | --- |
| 5 | |
| 6 | The forge is free: repositories, git, issues, pull requests and review cost |
| 7 | nothing, for public and private work. What costs money is compute, the |
| 8 | things g1t runs for you: agents, the sandboxes they and your workflows run in, |
| 9 | deployed apps, and, on the plan, storage and git traffic past the free |
| 10 | amounts. Each is charged at what it costs g1t plus 20%, to the workspace |
| 11 | that owns the repository. There is no seat price, and on the plan there |
| 12 | are no quotas: only your spend limit stops anything. |
| 13 | |
| 14 | Wherever this page says an owner can do something to a workspace's |
| 15 | billing, so can its [billing managers](/guides/workspaces/#roles-that-add-to-a-member): |
| 16 | starting or ending the plan, the spend limit and budget alerts, caps, |
| 17 | prepaying and AI credit, the card and billing details. Deleting the |
| 18 | workspace stays with owners. |
| 19 | |
| 20 | ## What is free |
| 21 | |
| 22 | Every workspace, with or without the plan, has the whole forge: |
| 23 | |
| 24 | - Public and private repositories, git, issues, pull requests and reviews. |
| 25 | - Protected branches, code owners and secret push protection. |
| 26 | - [Security scans](#storage-search-embeddings-and-scans) of history and |
| 27 | dependencies, which g1t pays for on a free workspace. |
| 28 | - Search and Explore. |
| 29 | - The [audit log](/guides/audit-log/), with export: kept 7 days, or 90 on |
| 30 | the plan. |
| 31 | - Your own agent through [MCP](/reference/mcp/). |
| 32 | - 1 GB of private repository storage, and 50,000 |
| 33 | [git operations](#git-operations) a month. |
| 34 | |
| 35 | None of this is charged, on the plan or not. A free workspace is never |
| 36 | charged for storage: once its private repositories hold 1 GB, pushes to |
| 37 | them are refused at the start of the push, with what to do: make the |
| 38 | repository public, delete what you do not need, or start the plan, where |
| 39 | storage past 1 GB is usage and pushes never stop. Public repositories are |
| 40 | never charged for storage. |
| 41 | |
| 42 | Compute is not free. Agents, workflows, the merge queue, |
| 43 | deployments and semantic search need [the g1t plan](#the-g1t-plan), or a |
| 44 | [card check](#no-card-no-compute) for the trial and the open-source pool. |
| 45 | |
| 46 | ### One free workspace per person |
| 47 | |
| 48 | Each person can own **one free workspace**: a workspace that is not on the |
| 49 | g1t plan, an enterprise's terms or a full discount. A new workspace starts |
| 50 | free, so while you own a free workspace, creating another is refused with |
| 51 | the way forward: |
| 52 | |
| 53 | 1. Start the plan on the free workspace you have |
| 54 | ([Start or end the plan](#start-or-end-the-plan)), or |
| 55 | 2. delete it, if you no longer use it |
| 56 | ([Delete a workspace](/guides/workspaces/)). |
| 57 | |
| 58 | Then create the new one. If you owned several free workspaces before this |
| 59 | rule, you keep them all, but you cannot create another until each of them |
| 60 | is on the plan or deleted. Workspaces you belong to without owning them do |
| 61 | not count. The site's **New workspace** page says so before you start; |
| 62 | `POST /workspaces` and the MCP `workspace` tool's `create` action answer |
| 63 | `402` (`payment_required`) with the same message. |
| 64 | |
| 65 | ### Who a free workspace can add |
| 66 | |
| 67 | A free workspace keeps the people already in it, but **cannot add anyone** |
| 68 | until it starts the plan: |
| 69 | |
| 70 | - no new members, by username or by email invite; |
| 71 | - no outside collaborators on its repositories, and no invitations to them; |
| 72 | - an invite or invitation sent before cannot be accepted until then (it |
| 73 | waits, and works once the plan is on). |
| 74 | |
| 75 | Its members can still be given a role on its repositories, and put on its |
| 76 | [teams](/guides/teams/). On the **People** page and a repository's |
| 77 | **Settings → Access**, an owner sees **Start the plan to invite people** |
| 78 | with a button to the plan. Through the API and MCP, adding a member, |
| 79 | inviting, adding an outside collaborator and accepting are refused with |
| 80 | `402` (`payment_required`). g1t's own agent, `@g1t`, works in every |
| 81 | workspace and never counts as someone added. |
| 82 | |
| 83 | Your own machines are. Workflow jobs on |
| 84 | [self-hosted runners](/guides/self-hosted-runners/) cost nothing, on every |
| 85 | plan, the free one included, and need no card; their minutes show on usage |
| 86 | as **Self-hosted runner time** at $0. Agent work you send to your runners |
| 87 | still needs its model paid for, unless it uses your own model provider. |
| 88 | |
| 89 | ## The g1t plan |
| 90 | |
| 91 | One plan, **$20 a month per workspace**, however many people and agents |
| 92 | are in it. It is never priced per person. Like every price on g1t, it |
| 93 | excludes tax ([Tax](#tax)), and paid by card it carries Stripe's |
| 94 | [card processing fee](#card-processing-fee) as its own line, $0.91 a month |
| 95 | on $20. |
| 96 | |
| 97 | - **$10 of usage each month** at cost plus 20%, used first. |
| 98 | - **Everyone in the workspace** at one price, never per person. |
| 99 | - **Unlimited** projects, previews and repositories. |
| 100 | - Agents, workflows, the merge queue, |
| 101 | [deployments](/guides/deployments/) and semantic search. |
| 102 | - **90 days** of [audit log](/guides/audit-log/#how-long-it-is-kept), in |
| 103 | place of a free workspace's 7. |
| 104 | - Usage past $10 is charged at cost plus 20%, **up to your |
| 105 | [spend limit](#limits)**. |
| 106 | |
| 107 | There are **no quotas** on the plan: no count of projects, previews, |
| 108 | build minutes, requests, custom domains, git operations or gigabytes |
| 109 | stops a workspace. Everything that costs g1t money is metered from the |
| 110 | first unit (past the free 1 GB of private storage and 50,000 git |
| 111 | operations that every workspace has), and only your spend limit stops |
| 112 | work. |
| 113 | |
| 114 | **Included usage** pays for the month's usage first, at the same prices as |
| 115 | everything else: agents, sandbox time, builds, app traffic, custom domains, |
| 116 | storage, git operations, search embeddings and security scans. Past it, |
| 117 | usage is charged at cost plus 20%. It starts again on the 1st of each |
| 118 | month (UTC). **Unused included usage does not roll over.** Billing shows |
| 119 | how much of it this month's usage has drawn. |
| 120 | |
| 121 | ### What it costs |
| 122 | |
| 123 | Every price is what g1t pays plus 20%, except models: they are charged at |
| 124 | the provider's price with no markup, and g1t's own part is the agent rate. |
| 125 | The live figures are on [g1t.sh/pricing](https://g1t.sh/pricing). |
| 126 | |
| 127 | | What | Unit | Costs g1t | You pay | |
| 128 | | --- | --- | --- | --- | |
| 129 | | Agent models | A run | What the provider charged | The provider's price, from [AI credit](#ai-credit) | |
| 130 | | g1t agent rate | Million tokens a run uses (input, output and cached), [weighted by kind](#the-agent-rate) | — | $0.25, from Oct 22, 2026 | |
| 131 | | g1t agent rate, your own model key | The same, on runs that use [your own provider](/guides/models/) | — | $0.25, from Oct 22, 2026 | |
| 132 | | [AI Gateway](/guides/ai-gateway/) | A request | What the provider charged | The model's list price per token: free of markup during beta | |
| 133 | | Sandbox time (agents, workflows, the merge queue) | Second | About $0.001 a minute | About $0.0012 a minute | |
| 134 | | [Larger machines](#workflow-jobs-on-larger-machines) for workflow jobs (`g1t-2core`, `g1t-4core`) | Second | About 2.8 and 5.1 times a sandbox second | Cost + 20% | |
| 135 | | Deploy builds | Second | About $0.001 a minute | About $0.0012 a minute | |
| 136 | | App requests | Million | $0.30 | $0.36 | |
| 137 | | App CPU time | Million CPU milliseconds | $0.02 | $0.024 | |
| 138 | | Custom domains | Domain-month | $0.10 | $0.12 | |
| 139 | | Private storage, past the free 1 GB | GB-month | $0.50 | $0.60 | |
| 140 | | [Actions cache](#actions-cache) storage | GB-month | $0.015 | $0.018 | |
| 141 | | Git operations, past the free 50,000 a month | 1,000 | $0.15 | $0.18 | |
| 142 | | Search embeddings | Million tokens | $0.067 | $0.0804 | |
| 143 | | Security scans | Million CPU ms / million rows | $0.02 / $1.00 | $0.024 / $1.20 | |
| 144 | | Projects, previews, apps and repositories | | Next to nothing | Not charged | |
| 145 | |
| 146 | Sandbox and build seconds follow what Cloudflare bills g1t, so the |
| 147 | figures above move a little; the pricing page always has today's. |
| 148 | Actions cache storage is charged at R2's published price, and is not on |
| 149 | the pricing page yet. |
| 150 | |
| 151 | **The other $10** pays for running g1t, the free forge everyone uses, and |
| 152 | the people building it. |
| 153 | |
| 154 | Deployments are part of the plan. There is no separate Deployments |
| 155 | purchase. |
| 156 | |
| 157 | ### Start or end the plan |
| 158 | |
| 159 | Only an owner can start or end the plan. |
| 160 | |
| 161 | 1. Open **Settings → Billing and plans**, `g1t.sh/<workspace>/-/billing`. |
| 162 | 2. On the **g1t** card, choose **Start the g1t plan**. |
| 163 | 3. If the workspace already has a checked card, the plan starts on it at |
| 164 | once. Otherwise, pay on the card page you are sent to. |
| 165 | |
| 166 | Back on Billing, the plan's card says **On the g1t plan** (**first month** |
| 167 | in the first billing cycle), with the billing period, a meter for the |
| 168 | month's included usage, and the **Upcoming invoice**: the plan and add-ons |
| 169 | at their monthly price plus usage still owed after included usage, credit |
| 170 | and any discount, from g1t's own ledger (**View upcoming invoice** splits |
| 171 | it). **Usage** and **Invoices** go to each. Runs on your own model provider |
| 172 | are not in it: your provider bills those. App traffic, custom domains, |
| 173 | storage and git operations are counted through the month and charged when |
| 174 | it closes. **Downgrade to free at the period's end** ends the plan then, |
| 175 | with nothing more charged after; **Keep the plan** takes that back until |
| 176 | then. If a renewal payment fails, the card says **Payment failed**, and the |
| 177 | plan's features stop until it is paid: update the card with **Manage in |
| 178 | Stripe** under **Payment method**. |
| 179 | |
| 180 | Starting the plan uses the card from the card check, or else the default |
| 181 | card on Stripe's billing page, without a second page; with neither, Stripe's |
| 182 | page asks for one. If Stripe refuses, the page says why in a sentence. |
| 183 | |
| 184 | A card that says **100% discount from g1t** or **Included by g1t** is on |
| 185 | under terms g1t set with the workspace, such as a |
| 186 | [100% discount](#enterprises-and-custom-terms), with nothing to pay or end. |
| 187 | |
| 188 | ## No card, no compute |
| 189 | |
| 190 | Compute costs g1t real money from the first second, and free compute |
| 191 | attracts people who use it to mine cryptocurrency. A card check is the |
| 192 | smallest gate that stops that: it puts a real card behind each workspace, |
| 193 | and each card gets one trial. |
| 194 | |
| 195 | A free workspace needs a card check before its trial or g1t's open-source |
| 196 | pool pays for anything. Only an owner can do it. |
| 197 | |
| 198 | 1. Open **Settings → Billing and plans**. |
| 199 | 2. Under **Try it with $5 of usage**, choose **Check a card**. You are sent |
| 200 | to Stripe's card page. |
| 201 | 3. Enter the card. If your bank asks for 3-D Secure, confirm it there. |
| 202 | |
| 203 | The card check is **never charged**: Stripe saves and verifies the card, |
| 204 | and nothing is taken. Back on Billing, a line says whether the trial |
| 205 | started. The card is saved as the workspace's card, so starting the plan |
| 206 | later needs no second card page. |
| 207 | |
| 208 | The trial needs a credit or debit card; prepaid cards can still pay for the |
| 209 | plan. A prepaid card passes the check, and unlocks the open-source pool, |
| 210 | but starts no trial. |
| 211 | |
| 212 | The card check unlocks: |
| 213 | |
| 214 | - [The trial](#the-trial): $5 of usage, once. |
| 215 | - [The open-source pool](#the-open-source-pool): checks, workflows and |
| 216 | the merge queue on public repositories. |
| 217 | |
| 218 | ## The trial |
| 219 | |
| 220 | Once its card is checked, a workspace gets **$5 of trial credit**, once. It |
| 221 | pays for usage at cost plus 20%: agents, sandbox time, workflows, |
| 222 | the merge queue and semantic search. It never pays for deployments. |
| 223 | |
| 224 | - Each card gets one trial, whichever workspace it is checked in. Prepaid |
| 225 | cards start none. |
| 226 | - Trials come from a pool of **$100 a month** for everyone together. It |
| 227 | renews on the 1st of each month (UTC). When a month's pool is given out, |
| 228 | new trials wait until the 1st, and **Settings → Billing** says so. |
| 229 | - Billing and mission control show what is left. |
| 230 | - While on the trial, a workspace runs at most 2 agents at once, and each |
| 231 | run for at most 60 minutes. See [caps](#caps). |
| 232 | - While payments are in test mode, the trial does not open g1t's hosted |
| 233 | models: its agents run on the workspace's own |
| 234 | [model provider](/guides/models/), and the trial pays for their sandbox |
| 235 | time. |
| 236 | |
| 237 | The trial does not turn into a charge. Nothing is charged until an owner |
| 238 | starts the plan. If a free workspace's last trial run goes past what was |
| 239 | left, g1t covers the difference, and the statement shows it as **Covered |
| 240 | by g1t**. When the trial is used up, new compute waits for the plan. |
| 241 | |
| 242 | ## The open-source pool |
| 243 | |
| 244 | g1t sets aside **$25 a month** for public repositories, at most **$2 a |
| 245 | month** for any one repository. It pays for **checks, workflows and the |
| 246 | merge queue on public repositories**, after a card check. It does not pay |
| 247 | for agents, deployments, storage or embeddings. |
| 248 | |
| 249 | When the pool or the repository's share is spent, those runs wait for the |
| 250 | next month, or for the plan. Each statement line the pool paid says so, |
| 251 | and the month's statement totals it under **Paid by g1t's open-source |
| 252 | pool**. |
| 253 | |
| 254 | ## What is charged |
| 255 | |
| 256 | | | Charged | |
| 257 | | --- | --- | |
| 258 | | Making a change for an issue | Yes | |
| 259 | | Revising a change after checks, a review or a person | Yes | |
| 260 | | A review by g1t | Yes | |
| 261 | | Catching up with `main` | Yes, when it needed an agent | |
| 262 | | Planning an [outcome](/guides/outcomes/) | Yes | |
| 263 | | The [merge queue](/guides/merge-queue/) | [Sandbox time](#sandbox-time) | |
| 264 | | [Workflow](/guides/actions/) jobs | [Sandbox time](#sandbox-time), more on a [larger machine](#workflow-jobs-on-larger-machines) | |
| 265 | | [Actions cache](#actions-cache) | What it holds, on the plan only | |
| 266 | | [Deployments](/guides/deployments/) | Builds, requests, CPU time and custom domains, from the first. Projects and previews are not charged. | |
| 267 | | [Private repository storage](#storage-search-embeddings-and-scans) | Past the free 1 GB, on the plan only | |
| 268 | | [Git operations](#git-operations) | Past the free 50,000 a month, on the plan only | |
| 269 | | [Search embeddings](#storage-search-embeddings-and-scans) | For private text, on the plan only | |
| 270 | | [Security scans](#storage-search-embeddings-and-scans) | On the plan only | |
| 271 | | Repositories, issues, pull requests, review, search, the API and MCP | No | |
| 272 | |
| 273 | Each run is charged when it finishes: what the model provider charged for |
| 274 | it, with no markup; the agent rate on the tokens it used, on a line of its |
| 275 | own (*g1t agent rate: 1,240,000 tokens for work on acme/api#12*); and its |
| 276 | sandbox time. A small change costs a few cents. Tokens counted after a run |
| 277 | reports are charged when it is settled. Until Oct 22, 2026 the agent rate is |
| 278 | $0, and from Oct 8, 2026 models carry no markup (before, cost plus 20%); both |
| 279 | are dated changes on the pricing page. |
| 280 | |
| 281 | Work a workspace routes to [its own model providers](/guides/models/) is |
| 282 | paid for at those providers instead. Such a run is charged here for its |
| 283 | [sandbox time](#sandbox-time), like any other sandbox, and the agent rate |
| 284 | on the tokens it used, on a line of its own (*g1t agent rate, your own |
| 285 | model key: 980,000 tokens for work on acme/api#12*). |
| 286 | |
| 287 | ### The agent rate |
| 288 | |
| 289 | The agent rate pays for what g1t adds around the model: context, memory, |
| 290 | routing and orchestration. It is charged per million tokens a run used, |
| 291 | on g1t's models and on your own model key alike: |
| 292 | |
| 293 | 1. g1t's model proxy counts each answer's tokens as it passes: input, |
| 294 | output, and prompt-cache reads and writes. The sandbox reports what its |
| 295 | agent counted too, and the rate is charged on the more of the two. |
| 296 | 2. Each kind of token counts at its weight: input ×1, output ×1, cache |
| 297 | writes ×1, and cache reads ×0.1, as model providers price them. The weights |
| 298 | are on [g1t.sh/pricing](https://g1t.sh/pricing) under the rate, and a |
| 299 | change to them is a dated price change like any other. |
| 300 | 3. The run is charged when it reports, and again for tokens counted after |
| 301 | that, never twice for the same token. |
| 302 | |
| 303 | On the **Usage** page the agent rate's lines count weighted tokens and name |
| 304 | the weights: **Agent rate** for runs on g1t's models, and **Agent rate, your |
| 305 | own model key** for runs on your own provider. |
| 306 | |
| 307 | The charge goes to the workspace that owns the repository, whoever |
| 308 | assigned the issue. That is why putting g1t to work on a |
| 309 | repository needs the Write [role](/guides/access-and-roles/) or higher on it. |
| 310 | |
| 311 | ## Add-ons |
| 312 | |
| 313 | An add-on is a monthly price per workspace that turns on more of g1t. Each |
| 314 | is its own line on the workspace's Stripe subscription and is turned on or |
| 315 | off from **Billing → Add-ons**. |
| 316 | |
| 317 | | Add-on | Price | What it adds | |
| 318 | | --- | --- | --- | |
| 319 | | Security and quality | $10 a month | Custom secret patterns, validity checks, delegated bypass, code scanning, dependency review and the security overview on **private** repositories. Public repositories get all of it free. | |
| 320 | |
| 321 | Secret scanning, push protection, vulnerability alerts, security updates, |
| 322 | the dependency graph and SBOMs are free everywhere, without the add-on. An |
| 323 | add-on does not need the plan, and the plan does not include one. Agent work |
| 324 | it starts, such as **Fix with g1t**, is ordinary usage. See |
| 325 | [What's free and what's paid](/guides/security/pricing/). |
| 326 | |
| 327 | ## How prices are set |
| 328 | |
| 329 | Every price is what g1t pays for the thing, at Cloudflare or a model |
| 330 | provider, plus 20%. The live prices are on |
| 331 | [g1t.sh/pricing](https://g1t.sh/pricing), straight from the price book |
| 332 | billing charges from. |
| 333 | |
| 334 | | Meter | Unit | |
| 335 | | --- | --- | |
| 336 | | Models | What the provider charged for the run | |
| 337 | | Sandbox time | Per second: memory, disk and the Durable Object behind each container, plus CPU | |
| 338 | | Deploy builds | Per second | |
| 339 | | App requests and CPU | Per million requests, per million CPU milliseconds | |
| 340 | | Custom domains | Per domain-month | |
| 341 | | Private storage past the free 1 GB | Per GB-month | |
| 342 | | Actions cache storage | Per GB-month | |
| 343 | | Git operations past the free 50,000 a month | Per 1,000 | |
| 344 | | Search embeddings | Per million tokens | |
| 345 | | Security scans | Per million CPU milliseconds and per million rows written | |
| 346 | |
| 347 | Prices keep themselves current as those costs move: |
| 348 | |
| 349 | - **Models.** Each of g1t's hosted runs goes through its Cloudflare AI |
| 350 | Gateway, which prices every request at the provider's current rates. A |
| 351 | run is charged when it finishes at what the sandbox reported; within |
| 352 | about 15 minutes it is **settled** to the gateway's figure, and any |
| 353 | difference appears on the statement as a correction, such as |
| 354 | *Correction to "Work on acme/api#12": AI Gateway priced its 41 model |
| 355 | requests at $0.0312, not $0.0298*. A run whose sandbox stopped without |
| 356 | reporting is charged from the gateway's logs instead of not at all. When |
| 357 | the gateway has no price for a model a run used, the run is never settled |
| 358 | below what its sandbox reported, and the correction says so. |
| 359 | - **Cloudflare.** Every day, g1t checks what Cloudflare billed its account |
| 360 | against what was used: Containers and the Durable Objects behind them |
| 361 | against the seconds containers ran, Workers for Platforms per request |
| 362 | and per CPU millisecond. When a cost moves, the price book moves with |
| 363 | it, and the change is listed on the pricing page with the reason. A |
| 364 | large move, or a measurement far from the current cost, waits for a |
| 365 | person at g1t to check it, so one odd day cannot reprice anything. |
| 366 | |
| 367 | ### How we keep prices at cost |
| 368 | |
| 369 | Prices follow what Cloudflare charges g1t. Every day g1t reads its own |
| 370 | Cloudflare bill and sets it beside what it counted and what it charged |
| 371 | for the same things, product by product, so a price that no longer |
| 372 | matches its cost is found and corrected. |
| 373 | |
| 374 | - **A price that goes down** changes at once. |
| 375 | - **A price that goes up** is announced first: it is listed on |
| 376 | [g1t.sh/pricing](https://g1t.sh/pricing) with the day it takes effect, |
| 377 | and owners of workspaces on the plan are emailed. It takes effect 14 |
| 378 | days later, and for something charged once a month (git operations, |
| 379 | storage, the actions cache, custom domains, embeddings, scans) at the |
| 380 | start of the month after that, so no month is charged at two prices. |
| 381 | - **Nothing already charged changes.** Each charge records the price it |
| 382 | was made at. |
| 383 | |
| 384 | Some of the Cloudflare products g1t pays for are in beta and do not yet |
| 385 | define exactly what they bill; see |
| 386 | [What g1t can't do yet](/about/limitations/#billing). |
| 387 | |
| 388 | ### Sandbox time |
| 389 | |
| 390 | Every sandbox g1t starts runs on Cloudflare Containers, and Cloudflare |
| 391 | charges g1t for every second of it. So each one is metered by the second, |
| 392 | from start to stop, whatever it was for: agents, reviews, revisions, |
| 393 | catch-ups, planning, the merge queue and workflow jobs. |
| 394 | There are no free minutes. |
| 395 | |
| 396 | A sandbox second is priced in two parts: memory, disk and the Durable |
| 397 | Object behind the container, for every second; and CPU, for the vCPU it |
| 398 | used. A run whose sandbox reports its own CPU use is priced on it. One |
| 399 | that does not is priced at the average CPU sandboxes use. |
| 400 | |
| 401 | Each sandbox is one line on the [statement](#the-statement), such as |
| 402 | *Checks on acme/api#12: 3m 12s of sandbox time*. Deploy builds are not |
| 403 | counted here: [Deployments](/guides/deployments/) charges them by the |
| 404 | second, from the first, under **Builds**. |
| 405 | |
| 406 | ### Workflow jobs on larger machines |
| 407 | |
| 408 | A workflow job whose `runs-on` names a [larger machine](/guides/actions/#machine-sizes) |
| 409 | runs on a larger Cloudflare Containers instance, and its seconds cost what |
| 410 | that instance costs g1t, plus 20%: |
| 411 | |
| 412 | | `runs-on` | Instance | Its memory and disk, against the standard machine's | A second with its vCPUs as busy as an average sandbox's | |
| 413 | | --- | --- | --- | --- | |
| 414 | | `g1t-2core` | 2 vCPU, 8 GiB, 16 GB | 1.9 times | About 2.8 times a sandbox second | |
| 415 | | `g1t-4core` | 4 vCPU, 12 GiB, 20 GB | 2.7 times | About 5.1 times a sandbox second | |
| 416 | |
| 417 | A job that reports its own CPU is priced on it: its memory and disk for |
| 418 | every second, and the vCPU-seconds it used. One that does not is priced |
| 419 | at the right-hand column. Its line on the statement names the machine, |
| 420 | such as *A workflow job in acme/api on g1t-4core: 6m 40s of sandbox |
| 421 | time*. A job usually finishes several times sooner on a larger machine, |
| 422 | so it often costs about the same. |
| 423 | |
| 424 | ## Git operations |
| 425 | |
| 426 | Cloudflare charges g1t **$0.15 per 1,000 git operations** from 2026-10-14. |
| 427 | An operation is one clone or fetch (a request that fetches objects) or one |
| 428 | push, and making, forking or deleting a repository: what Cloudflare bills |
| 429 | g1t for. Listing refs, and anything g1t answers from its own cache, is |
| 430 | never an operation: a repeat clone of the same commit is served from |
| 431 | g1t's [pack cache](/guides/git/#where-a-slow-requests-time-went) and is not |
| 432 | counted. g1t meters every request it makes to the store, and |
| 433 | what counts follows what Cloudflare confirms it bills; this page changes |
| 434 | with it. |
| 435 | |
| 436 | Your agents' git counts the same as yours. Agent runs, checks, reviews, |
| 437 | builds and workflow jobs clone, fetch and push through the same git |
| 438 | endpoints you use, and so does any git command an agent runs itself. Each |
| 439 | counts for the workspace whose repository it is. A pull request's working |
| 440 | copy, where an agent clones and pushes its changes, counts for the |
| 441 | workspace of the repository the pull request is in. g1t's own nightly |
| 442 | backups are never counted for your workspace. |
| 443 | |
| 444 | | | Each month (UTC) | |
| 445 | | --- | --- | |
| 446 | | Free, on every workspace | 50,000 | |
| 447 | | On the plan, past 50,000 | $0.18 per 1,000 (cost plus 20%). Never slowed or refused. | |
| 448 | | Free workspace, past 50,000 | Not charged. Slowed to 60 an hour until the month turns. | |
| 449 | |
| 450 | 50,000 is far more than an active workspace uses; an agent run takes two |
| 451 | to four. A workspace on the plan pushes and clones on past it and pays for |
| 452 | what it uses, up to its spend limit. A free workspace is never charged for |
| 453 | git operations: past 50,000 in a month, its git requests past 60 in an |
| 454 | hour are answered `429` with when to try again. |
| 455 | |
| 456 | Charging starts on 2026-10-14: operations before then are never charged. |
| 457 | **Billing** shows this month's count under **Git operations & storage**. |
| 458 | |
| 459 | ## Storage, search embeddings and scans |
| 460 | |
| 461 | These are counted through the month and charged once it is over, as one |
| 462 | line dated the month's last day, so the limit counts them as they happen. |
| 463 | The plan's included usage and the trial pay for them first. |
| 464 | |
| 465 | Security scans and search embeddings run on every workspace, with or |
| 466 | without the plan. On a free workspace g1t pays for them itself. They appear on the statement at $0, *covered by g1t*, never count |
| 467 | toward the limit and never use the trial. |
| 468 | |
| 469 | | | What it costs g1t | What is counted | |
| 470 | | --- | --- | --- | |
| 471 | | Private repository storage | $0.50 a GB-month (Cloudflare Artifacts) | On the plan, each day, what the workspace's private repositories hold past the free 1 GB. A month's GB-months are those days added up, divided by 30. | |
| 472 | | Search embeddings | $0.067 per million tokens (Workers AI) | The text of private repositories, issues and pull requests put in the search index. Public text and searches are not charged. | |
| 473 | | Security scans | $0.02 per million CPU milliseconds and $1.00 per million rows written (Workers and D1) | The CPU each history scan and dependency check takes and the rows it writes. | |
| 474 | |
| 475 | ### Actions cache |
| 476 | |
| 477 | What a workspace's [`actions/cache`](/guides/actions/#the-cache) entries and its runs' |
| 478 | [artifacts](/guides/actions/#artifacts) hold is measured every hour, and each day's largest figure counts. A |
| 479 | month's GB-months are those days added up, divided by 30, charged at |
| 480 | $0.018 a GB-month: R2's $0.015, plus 20%. It is charged from the first |
| 481 | byte, to workspaces on the plan only, as **Actions cache storage** under |
| 482 | **Git operations & storage**. A free workspace's caches are never charged; |
| 483 | they are held to the same 10 GiB a repository, and 10 GiB of artifacts a run, as everyone's. |
| 484 | |
| 485 | ### Private repository storage |
| 486 | |
| 487 | Storage is charged at $0.60 a GB-month (cost plus 20%). It is measured from |
| 488 | the packs pushed through g1t's git endpoints to each repository and its |
| 489 | pull requests' working copies, so what is charged is never more than what |
| 490 | is stored. Public repositories are never charged, and neither is a free |
| 491 | workspace: its pushes to private repositories stop at 1 GB instead. On the |
| 492 | plan they never stop. |
| 493 | |
| 494 | ## Limits |
| 495 | |
| 496 | Every workspace has two limits: **g1t's ceiling** on usage not yet paid |
| 497 | for, and **your spend limit** on what is charged in a month. Work stops at |
| 498 | whichever is lower. Both are in the **Spend limit** section of **Settings → |
| 499 | Billing and plans**, on the plan. |
| 500 | |
| 501 | ### The ceiling |
| 502 | |
| 503 | Usage is charged after it runs, so at any moment some of it is not yet |
| 504 | paid. g1t lets that reach a ceiling that grows with your history: |
| 505 | |
| 506 | | | Ceiling on what is unpaid | |
| 507 | | --- | --- | |
| 508 | | **Free** | None to reach: a free workspace is never charged. The trial and g1t's pools pay for its compute. | |
| 509 | | **First month on the plan** | $100 | |
| 510 | | **Paid** | Twice what you have paid, never below $100, up to $1,000 | |
| 511 | | **Established**: three steady months | Three times your monthly spend, up to $10,000 | |
| 512 | | **Reviewed** | What g1t set with you | |
| 513 | |
| 514 | - A payment counts once it has **cleared for 7 days**, the time in which |
| 515 | most bad cards are caught. Credits g1t gives and payments in test mode |
| 516 | do not raise the ceiling. |
| 517 | - **Established** comes by itself after three months in a row of $20 or |
| 518 | more, every invoice paid, nothing declined in 90 days and nothing ever |
| 519 | disputed. |
| 520 | - **Prepaying** raises what can be used before work stops by the same |
| 521 | amount, at once. See [prepay](#prepay). |
| 522 | |
| 523 | With a card on file, **g1t charges it as you near the ceiling** (80%): an |
| 524 | invoice for what you owe, paid at once, after which the ceiling is yours |
| 525 | again. A workspace that pays keeps going; the ceiling stops one that does |
| 526 | not. |
| 527 | |
| 528 | What counts as unpaid is each item at what it cost g1t or what it is |
| 529 | charged, whichever is more, less what was paid this month, plus anything |
| 530 | left unpaid from earlier months. What included usage, the trial or the |
| 531 | open-source pool paid for does not count. |
| 532 | |
| 533 | ### Your spend limit |
| 534 | |
| 535 | What the workspace may be charged in a month (UTC). At it, new work stops |
| 536 | until the month turns or an owner raises it. Until owners set one, it is |
| 537 | **automatic**: $200, or twice last month's spend, whichever is more, up to |
| 538 | what is available. |
| 539 | |
| 540 | Owners set it under **Your monthly spend limit**: **Automatic**, **Fixed |
| 541 | at** an amount, **Everything available**, or, once, **Use my one-time |
| 542 | raise**, then **Save limit**. The section says how far you can go yourself, |
| 543 | and whether the one-time raise is still yours: |
| 544 | |
| 545 | | | Up to | |
| 546 | | --- | --- | |
| 547 | | Any amount | The highest ceiling the workspace has had, plus what is prepaid | |
| 548 | | **The one-time raise**, once per workspace | Twice the highest ceiling | |
| 549 | | Past that | **Raise my limit**: a request to g1t | |
| 550 | |
| 551 | To ask for more, use the **Raise my limit** section: give the limit you |
| 552 | need, what you expect to spend a month, and what it is for, then **Send the |
| 553 | request**. A person at g1t answers **within one business day**, in the app |
| 554 | and by email, and the section shows the request and its answer. An approved amount becomes a |
| 555 | floor under your ceiling, and your spend limit can go up to it. |
| 556 | |
| 557 | ### Budget alerts |
| 558 | |
| 559 | The spend limit is the workspace's monthly **budget** on usage past what the |
| 560 | plan includes. Under **Budget alerts**, owners choose: |
| 561 | |
| 562 | | Setting | Means | |
| 563 | | --- | --- | |
| 564 | | **Alert at** | Any of 50, 75, 90 and 100% of the spend limit. Each is emailed to the owners once a month. | |
| 565 | | **Pause usage at 100%** | On (the default), new work stops at the limit. Off, the budget only alerts; g1t's own ceiling still applies. | |
| 566 | | **Webhook** | An `https://` address of your own, sent a JSON `POST` at each alert: `event` (`budget.alert`), `workspace`, `level_percent`, `spent_micros`, `budget_micros`, `sent_at`. | |
| 567 | |
| 568 | Choose **Save alerts**. Through the API: `PUT /workspaces/:workspace/budget`, |
| 569 | or the MCP `billing` tool's `set_budget` action. |
| 570 | |
| 571 | ### Prepay |
| 572 | |
| 573 | Paying in advance pays for usage as it happens, after the plan's included |
| 574 | usage, and raises what can be used before work stops by the same amount, |
| 575 | at once. It is never needed to start work. Only an owner can prepay. |
| 576 | |
| 577 | 1. Open **Settings → Billing and plans**, and find **Prepay**. |
| 578 | 2. Choose **By card, with 3-D Secure** or **By bank transfer** (from |
| 579 | $1,000). |
| 580 | 3. Choose $100, $500 or $1,000, or type your own amount, from $25, and |
| 581 | choose **Prepay**. By card, the most is $10,000. |
| 582 | 4. Pay on the page you are sent to, confirming 3-D Secure if your bank |
| 583 | asks. A bank transfer page gives the account details, and the amount |
| 584 | counts when the money arrives. |
| 585 | |
| 586 | By card, the [card processing fee](#card-processing-fee) is its own line |
| 587 | (the card shows it for $100, $500 and $1,000); a bank transfer has none. |
| 588 | [Tax](#tax) is added where it applies. What you prepay is credited in full: |
| 589 | neither the fee nor the tax comes from it. |
| 590 | |
| 591 | **Prepaid balance** shows what is paid in advance and not used yet. |
| 592 | |
| 593 | ### Caps |
| 594 | |
| 595 | The plan also caps what agents can do at once and spend: |
| 596 | |
| 597 | | Cap | First month on the plan, or the trial | After | Who sets it | |
| 598 | | --- | --- | --- | --- | |
| 599 | | Agents at once | 2 | 10 | g1t | |
| 600 | | Time per run | 60 minutes | The [guardrails](/guides/guardrails/)' own caps | g1t | |
| 601 | | Spend per run | $2 | $2 | Owners, from $0.10 to $100 | |
| 602 | | Agents' spend per issue | $10 | $10 | Owners, from $1 to $1,000 | |
| 603 | |
| 604 | Owners set the run and issue caps under **Caps on agents** on **Billing**, |
| 605 | then **Save caps**; a blank field goes back to the default. A cap g1t staff |
| 606 | set for the workspace wins over both. When an issue's agents reach its cap, |
| 607 | the message links straight to that section. See |
| 608 | [caps on a plan](/guides/working-with-g1t/#caps-on-a-plan) for what happens at |
| 609 | each. |
| 610 | |
| 611 | ### Alerts |
| 612 | |
| 613 | Owners are told at **50%, 75%, 90% and 100%** of each of: |
| 614 | |
| 615 | - the plan's included usage, |
| 616 | - your spend limit, |
| 617 | - g1t's ceiling. |
| 618 | |
| 619 | Each alert shows at the top of **Billing** and is emailed. |
| 620 | |
| 621 | ### Spikes |
| 622 | |
| 623 | If the last hour's spend is more than **5 times the workspace's usual |
| 624 | hour** over the last week, and at least **$5**, new compute pauses until an |
| 625 | owner answers. Runs already under way finish. A banner across the top of |
| 626 | every page in the workspace says so, and **Billing** shows the spike with |
| 627 | two choices, for owners on both: |
| 628 | |
| 629 | - **Keep going**: compute starts again, for 24 hours or until the hour's |
| 630 | spend doubles again, whichever comes first. |
| 631 | - **Stop**: compute stays paused until an owner chooses **Keep going**. |
| 632 | |
| 633 | g1t's own workspaces are never paused. |
| 634 | |
| 635 | ### Spent more than you meant to |
| 636 | |
| 637 | If a month went past what you meant to spend, use **Spent more than you |
| 638 | meant to? Tell us.** on **Billing**: say what happened and choose **Tell |
| 639 | g1t**. Once in 12 months per workspace, g1t can credit the overage above |
| 640 | your usual month: always the 20% g1t added to it, and what it cost g1t up |
| 641 | to $50. Larger credits, or a second one within 12 months, are reviewed by a |
| 642 | person. The credit appears on the statement with the day it happened, |
| 643 | such as *Credit from g1t: accidental usage on 2026-11-12*. |
| 644 | |
| 645 | ## AI credit |
| 646 | |
| 647 | Agent and AI Gateway usage is prepaid: a workspace on the plan buys **AI |
| 648 | credit**, and model usage draws on it, so g1t never fronts a model's cost. |
| 649 | The plan's included usage pays first; AI credit pays next, before any other |
| 650 | credit. Starting the plan comes with **$5 of AI credit, once** (it expires |
| 651 | a year after it is given). |
| 652 | |
| 653 | ### Buy AI credit |
| 654 | |
| 655 | Only an owner can buy it. |
| 656 | |
| 657 | 1. Open **Settings → Billing and plans**, and find **AI credit**. |
| 658 | 2. Choose $10, $25, $50 or $100, or **Custom** and type a whole-dollar |
| 659 | amount from $10 to $1,000. |
| 660 | 3. Choose **Buy AI credit**, and pay on Stripe's page. |
| 661 | |
| 662 | The [card processing fee](#card-processing-fee) is its own line on that |
| 663 | page, and shown on Billing before you go there (on $25, *Card processing |
| 664 | fee $1.06, plus tax where it applies*), so the credit you get is the amount |
| 665 | you chose. [Tax](#tax) is added on top where it applies. The credit is |
| 666 | added once Stripe says the payment was made, whether or not you come back |
| 667 | to g1t, and **expires 1 year after purchase**. The card is kept for |
| 668 | auto-reload, which charges the credit, its card fee and its tax together. |
| 669 | |
| 670 | ### Auto-reload |
| 671 | |
| 672 | Off by default. When it is on and AI credit falls below the amount you set, |
| 673 | g1t charges the saved card to bring it back to your target, in whole |
| 674 | dollars and at least $10, never more than your monthly maximum in a |
| 675 | calendar month (UTC). |
| 676 | |
| 677 | | Setting | Means | |
| 678 | | --- | --- | |
| 679 | | **When AI credit falls below** | The threshold, such as $10 | |
| 680 | | **Reload it to** | The target, at least $10 above the threshold, at most $1,000 | |
| 681 | | **At most … a month** | The most auto-reload charges in a month, up to $10,000 | |
| 682 | |
| 683 | g1t checks every 15 minutes, and right away when a run would otherwise |
| 684 | wait. If the card cannot be charged, auto-reload turns itself off and the |
| 685 | owners are emailed. Turn it on again after updating the card on Stripe. |
| 686 | |
| 687 | ### At $0 |
| 688 | |
| 689 | With no AI credit left and this month's included usage used, new runs on |
| 690 | g1t's models do not start, and the reason says to buy credit or turn on |
| 691 | auto-reload. Runs already going finish. Runs on your |
| 692 | [own model provider](/guides/models/) are not affected. A workspace with a |
| 693 | 100% discount gets AI usage free through the discount, shown at its price |
| 694 | and then the discount; an enterprise is invoiced for it after use. |
| 695 | |
| 696 | ## Credits from g1t |
| 697 | |
| 698 | g1t sometimes adds credit to a workspace: a welcome or referral credit, an |
| 699 | apology, or a refund for something that went wrong. The workspace's owners |
| 700 | get an email when it does, and **Billing** shows a **Credits from g1t** |
| 701 | card with each credit in a line, such as *$25.00 credit, $12.40 left, |
| 702 | expires Jan 5*. |
| 703 | |
| 704 | | Kind | What it is | Expires | |
| 705 | | --- | --- | --- | |
| 706 | | Promotional | A welcome, a referral or an event. | Sometimes: the date is on the card and in the email. | |
| 707 | | Goodwill | An apology, or usage past what you meant forgiven. | Sometimes, as above. | |
| 708 | | Refund | Money back for something that went wrong, with what it is for. | Never. | |
| 709 | |
| 710 | How credit is used: |
| 711 | |
| 712 | 1. It is added to your balance at once, so it lowers what you owe and |
| 713 | raises what you can use before work stops. |
| 714 | 2. Usage is paid from credit before anything you prepaid, and from the |
| 715 | credit that expires soonest first. |
| 716 | 3. Given while the workspace owes for this month, it pays that first. |
| 717 | 4. Credit left when it expires stops counting, and the statement shows a |
| 718 | line for what expired. g1t can also withdraw credit given by mistake; |
| 719 | only what is left is withdrawn, never what was already used. |
| 720 | |
| 721 | Credit is never paid out as money, and is never charged to a card. On the |
| 722 | statement, credits, expiries and withdrawals are under **Credits from g1t**. |
| 723 | |
| 724 | ## Invoices |
| 725 | |
| 726 | Every charge is a real invoice from g1t, kept on Stripe's billing page |
| 727 | with its PDF and emailed as a receipt: |
| 728 | |
| 729 | - **When each month closes**, an invoice for what the workspace owes, |
| 730 | itemised: the plan, usage past what it includes, and anything left |
| 731 | unpaid from before. Prepaid money is taken off as *Paid in advance*. |
| 732 | - **When the workspace nears its ceiling** mid-month, the same, sooner. |
| 733 | - **When the workspace is deleted**, a final invoice for what it owes, |
| 734 | charged at once with no minimum. See |
| 735 | [deleting a workspace](/guides/workspaces/#what-billing-needs). |
| 736 | |
| 737 | Each is charged to the card on file, with the |
| 738 | [card processing fee](#card-processing-fee) and [tax](#tax) as lines of |
| 739 | their own. The Billing page lists them, with links to view each on Stripe |
| 740 | and download its PDF; each one's amount is the usage, with the fee and |
| 741 | tax under it. |
| 742 | |
| 743 | ## Tax |
| 744 | |
| 745 | Every price on g1t excludes tax. Stripe adds sales tax, VAT or GST where it |
| 746 | applies (Stripe Tax), worked out from the workspace's billing address, and |
| 747 | shows it as its own line before you pay and on every receipt and invoice. |
| 748 | The plan, add-ons, prepaying, AI credit, auto-reload and invoices are all |
| 749 | taxed the same way, as software as a service for business use. |
| 750 | |
| 751 | - **The address.** Stripe's payment pages always ask for a billing |
| 752 | address, and save it as the workspace's **Invoice details**. A card check |
| 753 | saves the card's billing address there too, if there is none yet. You |
| 754 | can change it under [Your card and billing |
| 755 | details](#your-card-and-billing-details). |
| 756 | - **A business tax ID.** Add it on Stripe's page or under **Invoice |
| 757 | details** (the kind, such as EU VAT, and the number). Stripe checks it |
| 758 | (**Verified by Stripe**, or **Stripe is checking it**) and applies it |
| 759 | where the law says so, such as a reverse charge. |
| 760 | - **No address, no charge.** Where Stripe has nothing to work tax out |
| 761 | from, g1t does not charge the card. Billing shows **Add a billing |
| 762 | address**, the owners are emailed once, and the charge goes through once |
| 763 | the address is saved. Nothing is lost, and work is not stopped for it. |
| 764 | In the United States the ZIP code is needed; elsewhere the country. |
| 765 | - **Tax exempt.** If your organisation is exempt, write to |
| 766 | support@g1t.sh with the certificate; Billing then says **Tax exempt**. |
| 767 | - **Refunds** give the tax back in proportion. |
| 768 | |
| 769 | Tax is never part of your balance or usage: the statement shows it as its |
| 770 | own line, beside the payment it came with. |
| 771 | |
| 772 | ## Card processing fee |
| 773 | |
| 774 | Paying by card adds Stripe's fee, **2.9% + $0.30**, as its own line, |
| 775 | **Card processing fee**, worked out so that what is left after Stripe's |
| 776 | fee is exactly what you paid for: $0.91 on the $20 plan, $1.06 on $25 of |
| 777 | AI credit. It is shown before you pay, on every card payment: |
| 778 | |
| 779 | | Payment | Card fee | |
| 780 | | --- | --- | |
| 781 | | The plan and add-ons, each month | Yes, a monthly line | |
| 782 | | Prepaying by card, and AI credit | Yes | |
| 783 | | Auto-reload, and invoices charged to the card | Yes | |
| 784 | | Prepaying by bank transfer | No | |
| 785 | | An enterprise's invoices | No | |
| 786 | |
| 787 | Tax applies to the fee as to what it is paid with. The fee pays Stripe, not |
| 788 | g1t: usage is still charged at cost plus 20%, and models at the provider's |
| 789 | price plus the agent rate. The statement shows card fees as their own line, |
| 790 | never from your balance. |
| 791 | |
| 792 | ### The minimum charge |
| 793 | |
| 794 | Only the month's close has a minimum: a card is not charged less than |
| 795 | **$5** then, so a payment's fee is never most of what is paid. When a month |
| 796 | closes owing less, the amount carries over to the next invoice that reaches |
| 797 | $5, as *Unpaid from earlier*. A charge made because a workspace is at or |
| 798 | near a limit always goes through, whatever the amount, so work can carry |
| 799 | on. |
| 800 | |
| 801 | ## Moving a repository between workspaces |
| 802 | |
| 803 | When a repository is [transferred](/guides/transferring-repositories/#billing), |
| 804 | usage from that moment is charged to the workspace it moved to: agent runs, |
| 805 | builds, app traffic, git operations and storage. What it used before stays |
| 806 | on the old workspace's bill, and runs already under way finish on the bill |
| 807 | they started on. |
| 808 | |
| 809 | ## Your card and billing details |
| 810 | |
| 811 | Cards live on **Stripe's billing page**, not on g1t: g1t never sees or |
| 812 | stores card numbers. On **Settings → Billing and plans**: |
| 813 | |
| 814 | - **Payment method** shows the default card (brand, last four digits and |
| 815 | expiry). **Manage in Stripe** opens Stripe's page, where an owner adds, |
| 816 | removes or replaces a card and makes one the default. The plan and |
| 817 | auto-reload charge the default card. |
| 818 | - **Invoice details** are kept on the workspace's Stripe customer and |
| 819 | printed on every invoice: the invoice email, company name, billing |
| 820 | address, tax ID (its kind and number), a purchase order, and the invoice |
| 821 | language. An owner edits them here and chooses **Save invoice details**. |
| 822 | [Tax](#tax) is worked out from the address, so the card says when there |
| 823 | is none yet (in the US it needs the ZIP code), shows Stripe's check of |
| 824 | the tax ID, and says **Tax exempt** or **Reverse charge** when that |
| 825 | applies. |
| 826 | - **Invoices** lists every invoice Stripe sent (the plan, add-ons, AI |
| 827 | credit and month-end usage), each with **View** and **PDF**. |
| 828 | - **Add-ons** lists what can be turned on beside the plan, such as the |
| 829 | [Security and quality activation](/guides/security/), with its price and |
| 830 | **Turn on** or **Turn off**. |
| 831 | |
| 832 | g1t support never takes card details by phone or email. |
| 833 | |
| 834 | If a card is declined, work stops until the workspace pays, and the |
| 835 | Billing page and the API say why. Replace the card or prepay to clear it. |
| 836 | A payment disputed with the card's bank stops work the same way. |
| 837 | |
| 838 | Through the API, `GET /workspaces/:workspace/billing_details` and |
| 839 | `GET /workspaces/:workspace/invoices` (the MCP `billing` tool's |
| 840 | `billing_details` and `invoices` actions) read the same. |
| 841 | |
| 842 | ## When work is stopped |
| 843 | |
| 844 | A workspace that cannot start compute starts nothing new. Assigning an |
| 845 | issue, planning, or asking for a review is refused with `402` and a |
| 846 | message saying why and what to do, with the page to do it on: start the |
| 847 | plan, check a card, raise the spend limit, answer a spike, or wait for the |
| 848 | next month's pool. |
| 849 | |
| 850 | A step g1t would take by itself, such as a revision or a review, stops |
| 851 | instead, and the pull request says **Needs you** with the reason. A |
| 852 | workflow job is recorded as failed with "Not started:" and the reason. |
| 853 | Runs already under way finish, so usage can go slightly past a limit. |
| 854 | |
| 855 | ## Security on every plan |
| 856 | |
| 857 | Every workspace, free or on the plan, has the [audit log](/guides/audit-log/), |
| 858 | with the same CSV and JSON export, and secret scanning, push protection, |
| 859 | vulnerability alerts and security updates. The rest of the security suite |
| 860 | (custom patterns, validity checks, delegated bypass, code scanning, |
| 861 | dependency review and the security overview) is free on public |
| 862 | repositories and, on private ones, the **Security and quality** |
| 863 | activation: a monthly price per workspace from the price book ($10 today), |
| 864 | turned on from the Billing page, with or without the plan. See |
| 865 | [what's free and what's paid](/guides/security/pricing/). What the plan changes is how long the log is |
| 866 | kept: [7 days free, 90 on the plan](/guides/audit-log/#how-long-it-is-kept), |
| 867 | and longer by arrangement. Single sign-on through your identity provider is not |
| 868 | built yet; when it is, it will be on every plan. |
| 869 | |
| 870 | ## Enterprises and custom terms |
| 871 | |
| 872 | Some accounts are billed differently, set up by g1t with you. Every price |
| 873 | is public; custom terms change how you pay, not what things cost. |
| 874 | |
| 875 | - **Enterprise**: one billing account paying for several workspaces. |
| 876 | Their usage and payments count together, against one limit, and each |
| 877 | workspace's Billing page says which enterprise pays for it. An |
| 878 | enterprise is **invoiced**: when each month closes, one invoice goes to |
| 879 | the enterprise's billing address, with a line for each workspace, due in |
| 880 | 30 days and paid by card or bank transfer. If it goes overdue, the |
| 881 | workspaces' work stops until it is paid. [Tax](#tax) is added from the |
| 882 | enterprise's billing address, which g1t keeps on its Stripe customer, and |
| 883 | an invoice never carries the card processing fee. |
| 884 | - **A discount**: a percentage off every usage charge, from a few percent |
| 885 | to 100%, with a reason, sometimes until a date. Prices themselves stay |
| 886 | the public ones. The statement shows every line at its price and the |
| 887 | discount beside it: the totals read **Usage at price**, **Discount |
| 888 | (30%)** and **Charged**, each day or project has a **Discount** line, and |
| 889 | the CSV has `price (USD)` and `discount (USD)` columns. The Usage page |
| 890 | shows usage at price too, with the discount and what was charged. |
| 891 | - **A 100% discount**: nothing is charged, and the plan is on without |
| 892 | being charged. The statement and the Usage page still show everything at |
| 893 | its price, so you can see what the workspace would pay. |
| 894 | - **A limit of its own**, or a larger share of the pools. |
| 895 | - **A longer audit log**: up to 400 days for every workspace the account |
| 896 | pays for, in place of the plan's 7 or 90. See |
| 897 | [how long it is kept](/guides/audit-log/#how-long-it-is-kept). |
| 898 | |
| 899 | g1t's own workspaces and those of Flagon, Inc., the company that makes g1t, |
| 900 | have a 100% discount. Their usage is shown at price and kept apart from |
| 901 | what customers pay. |
| 902 | |
| 903 | Each change is made by g1t staff and recorded with who made it and why. To |
| 904 | ask for one, write to [hey@flagon.io](mailto:hey@flagon.io). |
| 905 | |
| 906 | ## Earlier plans |
| 907 | |
| 908 | Deployments used to be a $5 plan of its own. It is part of the g1t plan |
| 909 | now. A Deployments subscription bought before keeps working until its |
| 910 | current period ends, and is not renewed. |
| 911 | |
| 912 | ## The Usage page |
| 913 | |
| 914 | A workspace's **Usage** page, `g1t.sh/<workspace>/-/usage`, shows what it |
| 915 | used, by product, project and day. Every member can see it, from **Usage** |
| 916 | in the workspace's sidebar. A project's own, `g1t.sh/<workspace>/<project>/usage`, |
| 917 | shows the same for that project. |
| 918 | |
| 919 | Every amount is **usage at price**: what was charged, plus what included |
| 920 | usage, credit or a discount paid for it. It is the one figure mission |
| 921 | control, the agent fleet, Usage and Billing all show, so they agree. |
| 922 | |
| 923 | The filters, in one row: |
| 924 | |
| 925 | | Filter | Choices | |
| 926 | | --- | --- | |
| 927 | | Period | **Current billing cycle** (the calendar month, UTC), **Last billing cycle**, the last 7, 30 or 90 days, or a **Custom range** of up to 400 days. The days it covers are shown beside it. | |
| 928 | | Products | Any of Agent, Sandboxes, AI Gateway, Deployments, Git & storage, Packages, Security & quality and Search. | |
| 929 | | Projects | Any of the projects with usage in the period. | |
| 930 | | Group by | Product, project or day, for the breakdown. | |
| 931 | | **⋯** | **Export CSV** (a row per day, product and meter) and the usage API. | |
| 932 | |
| 933 | Then: |
| 934 | |
| 935 | - **Included usage, credit and this range**: the plan's included usage this |
| 936 | month, AI credit and credit from g1t left, and what the range came to: |
| 937 | usage at price, then the discount (shown as *Discount (100%)* for a |
| 938 | workspace g1t covers in full), included usage and pools, credits applied, |
| 939 | and what is charged. |
| 940 | - **Consumption**: a column per day, week or month (**Daily**, **Weekly**, |
| 941 | **Monthly**), stacked by product, with **Cumulative** to add them up. |
| 942 | Hover or focus a column for each product's part; **Show as a table** has |
| 943 | every number. |
| 944 | - **The breakdown**: each product family with its meters (the agent's |
| 945 | model tokens, agent rate, agent rate on your own model key and sandbox |
| 946 | time; sandbox time; builds; git operations and private storage with what |
| 947 | is free; and so on), each with a trend line, how much was used and its |
| 948 | charge at price. Open a meter for its projects. The agent also shows its |
| 949 | runs, reviews, plans and checks, and its tokens by model. |
| 950 | |
| 951 | Storage, git operations, scans and search embeddings are metered through |
| 952 | the month and charged when it closes; until then they are marked pending. |
| 953 | Through the API: `GET /workspaces/:workspace/usage`, or the MCP `billing` |
| 954 | tool's `usage` action. |
| 955 | |
| 956 | ## The statement |
| 957 | |
| 958 | The **Billing** page ends with the workspace's statement, a month at a |
| 959 | time. Every member can see it. |
| 960 | |
| 961 | - **Totals.** What the month charged, what was paid and credited, and how |
| 962 | many entries make it up. |
| 963 | - **Grouped by day or by project.** Each day (or project) has one line |
| 964 | per kind of charge, with how many entries it holds and what they come |
| 965 | to: |
| 966 | |
| 967 | | Line | What it holds | |
| 968 | | --- | --- | |
| 969 | | Agent runs | Runs on g1t's models: the model at the provider's price (cost plus 20% before Oct 8, 2026). | |
| 970 | | Agent rate | The agent rate on runs on g1t's models. | |
| 971 | | Agent rate, your own model key | The agent rate on runs on your own provider. | |
| 972 | | Runs on your own model provider | Older months only: the flat fee runs on your own provider used to carry. | |
| 973 | | Sandbox time | Each sandbox's time. | |
| 974 | | Self-hosted runner time | Each job on your own runners, at $0. | |
| 975 | | Deployments | Builds as they finish; each month's requests, CPU time and custom domains when it closes. | |
| 976 | | Private storage | Storage past the free 1 GB, once a month. | |
| 977 | | Actions cache storage | What `actions/cache` and artifacts held, on the plan, once a month. | |
| 978 | | Git operations | Operations past the free 50,000, once a month. | |
| 979 | | Search embeddings | Private text put in the search index, once a month. | |
| 980 | | Security scans | History scans and dependency checks, once a month. | |
| 981 | | Payments | Card payments and invoices paid. | |
| 982 | | Credits from g1t | Credit g1t added (promotional, goodwill or a refund), and what of it expired or was withdrawn. See [Credits from g1t](#credits-from-g1t). | |
| 983 | | Refunds | Money given back to your card. | |
| 984 | | Tax | Tax paid with that day's payments. Not a charge, and not from your balance. | |
| 985 | | Card processing fees | Card fees paid with that day's payments. Not a charge, and not from your balance. | |
| 986 | |
| 987 | Payments are what reached your balance; the tax and card fee paid with |
| 988 | them are the two lines below them, and the totals say what they came to. |
| 989 | |
| 990 | - **Covered.** Below the totals, what paid for usage before it was |
| 991 | charged, each with its amount: |
| 992 | |
| 993 | | Line | What paid | |
| 994 | | --- | --- | |
| 995 | | Paid by your plan's included usage | The plan's $10 a month. | |
| 996 | | Paid by your trial credit | The one-time trial. | |
| 997 | | Paid by g1t's open-source pool | The pool, for public repositories. | |
| 998 | | Covered by g1t | A free workspace's last trial run past its trial. | |
| 999 | |
| 1000 | Each entry says in its description how much of it was paid this way. A |
| 1001 | month that closed under the [minimum charge](#the-minimum-charge) says |
| 1002 | what carried over. |
| 1003 | - **Open a line** to see its entries, 50 at a time, newest first. Each |
| 1004 | run links to the pull request it was for. |
| 1005 | - **Pick a month** to see an earlier one. |
| 1006 | - **CSV** downloads every entry of the month, with the line it falls under |
| 1007 | and what covered it, for your own books. Invoices from Stripe remain the |
| 1008 | record for what was charged to your card. |
| 1009 | |
| 1010 | ## The preview |
| 1011 | |
| 1012 | While payments on g1t are in test mode, g1t's hosted models are open only |
| 1013 | to the workspaces g1t runs itself. Every other workspace's agents and merge |
| 1014 | queue work with [its own model provider](/guides/models/), and |
| 1015 | the sandbox time is paid as above. When payments go live, every workspace |
| 1016 | can use g1t's hosted models. |
| 1017 | |
| 1018 | ## For services: entitlements, reserve, settle |
| 1019 | |
| 1020 | Every g1t service that starts something that costs money asks billing |
| 1021 | first. These RPCs are internal; they are documented so the behavior above |
| 1022 | can be traced. |
| 1023 | |
| 1024 | | RPC | Takes | Returns | |
| 1025 | | --- | --- | --- | |
| 1026 | | `entitlements` | `workspace` | What the workspace may do now (below). | |
| 1027 | | `reserve` | `workspace`, `repo`, `public`, `kind`, `estimateMicros` | A reservation, or a refusal. | |
| 1028 | | `settle` | `reservationId`, `actualMicros` | `true`, or `false` if it was settled or had lapsed before. Safe to repeat. | |
| 1029 | |
| 1030 | **`entitlements`** returns, among others: `plan` (`free`, `paid`, |
| 1031 | `internal` or `enterprise`), `compute` (may start compute at all), |
| 1032 | `trialMicrosLeft`, `trialVerified` (a card check is done), `firstMonth`, |
| 1033 | `maxConcurrentAgents`, `maxRunMinutes`, `runCapMicros`, `issueCapMicros`, |
| 1034 | `ceilingMicros`, `exposureMicros`, `heldMicros`, `prepaidMicros`, |
| 1035 | `includedMicros`, `includedUsedMicros`, `paused` (why compute is paused, |
| 1036 | or none), `spike`, `alerts`, `gitOperations` and `gitOperationsIncluded` |
| 1037 | (the git operations free for every workspace), `freePrivateStorageBytes` |
| 1038 | (the private storage free for every workspace) and `buildSecondsUsed`. |
| 1039 | None of these is a quota on the plan. |
| 1040 | |
| 1041 | **`usage_meters`** (`workspace`, `viewer`; members only) returns this |
| 1042 | month's usage in six lines, `agents`, `builds`, `requests`, `domains`, |
| 1043 | `git_storage` and `search_scans`, each with `micros` (at cost plus 20%, |
| 1044 | before included usage or a pool paid for it) and a `quantity` such as |
| 1045 | *42 build minutes*, each at price (what was charged plus what paid for it), as Usage measures it. |
| 1046 | |
| 1047 | **`usage_report`** (`workspace`, `viewer`, `from`, `until`, optional `products` and `projects`; members only) is what the Usage page reads: totals (`priceMicros`, `discountMicros`, `includedMicros`, `creditsMicros`, `chargedMicros`, `pendingMicros`), each day's usage by product, and every product family with its meters, their daily figures and their projects. |
| 1048 | |
| 1049 | **`reserve`** holds the work's estimated cost before it starts, so starts |
| 1050 | at the same moment cannot overshoot together. `kind` is `agent`, `check`, |
| 1051 | `workflow`, `queue`, `deploy` or `embedding`. `estimateMicros` is the most |
| 1052 | the work is expected to cost g1t **in millionths of a dollar, before the |
| 1053 | margin**; billing adds the margin. For an agent, that is its model's |
| 1054 | average plus its sandbox for its whole time cap. |
| 1055 | |
| 1056 | A reservation has an `id`, `paidBy` (`credit` for included usage, `trial`, |
| 1057 | `oss` or `on_demand`), `heldMicros` and `expiresAt`. A hold never settled |
| 1058 | **lapses after 3 hours**. A refusal has one of these codes and a message |
| 1059 | for the owner with the page to fix it on: |
| 1060 | |
| 1061 | | Code | Why | |
| 1062 | | --- | --- | |
| 1063 | | `not_paid` | No plan, and nothing else pays for this kind of work, or no card check yet. | |
| 1064 | | `trial_used` | The one-time trial is spent. | |
| 1065 | | `limit` | The spend limit or g1t's ceiling would be passed. | |
| 1066 | | `paused` | A spend spike is waiting for an owner, or g1t staff put a hold on compute. | |
| 1067 | | `oss_pool_empty` | The open-source pool, or the repository's share of it, is spent this month. | |
| 1068 | |
| 1069 | **`settle`** releases the hold with what the work cost, at cost before the |
| 1070 | margin. It never charges: the charge goes on the ledger the usual way when |
| 1071 | the work reports its usage. |