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