Pricing
What each plan costs and includes, what a sandbox hour and a million model tokens cost, and the limits that keep spending in check.
Plans
There is no price per member. You pay for machine time and model tokens, and a plan's monthly fee comes back to you as credit for them.
| Free | Pro | Ultra | Enterprise | |
|---|---|---|---|---|
| Monthly fee | $0 | $20 per organization | $200 per organization | By contract |
| Credit each month | $5, back to $5 on the 1st of each month (UTC) | $20 (the whole fee), renewed each billing period | $200 (the whole fee), renewed each billing period | By contract |
| When the credit is used up | Usage comes out of your credit balance; once that is used up too, new tests on the platform executor or in a sandbox can't start until the credit comes back. Top up, redeem a credit code or subscribe to Pro to keep going | The same: the balance, then new tests stop until the next period. Top up, redeem a credit code or upgrade to Ultra | The same: the balance, then new tests stop until the next period. Top up or redeem a credit code | Invoice or prepaid |
| Sandboxes at once | 1 | 3 | 10 | By contract |
| Longest run | 60 minutes | 240 minutes | 480 minutes | By contract |
| Assistant per day | $6.50 | $13 | $65 | By contract |
| Members | Unlimited | Unlimited | Unlimited | Unlimited |
The credit pays for everything metered below: sandbox time, the judge model, platform models, the assistant and storage. It doesn't roll over to the next period. Every limit is set and shown in what you are billed, as the pages show it (since 26 October 2026; some were in model bill before, $5 of model bill being $6.50).
A new organization starts on Free, with no card. An owner subscribes to Pro or Ultra under "Organization" → "Billing"; card payments, changing between Pro and Ultra, invoices and cancellation go through Stripe. A Pro or Ultra subscription that ends puts the organization back on Free. Where paying on the web isn't switched on yet, the billing page says so: write to admin@nice2.io to subscribe or top up, or to ask about Enterprise or paying in advance.
How spending works
- The period's credit first. Each period, usage comes out of the plan's credit: on Free the calendar month (UTC), on Pro and Ultra the billing period that starts on the day you subscribed.
- Then your credit balance. Past the credit, usage comes out of the organization's balance. You add to it by card (a top-up of $5 to $1,000, in whole dollars) or with a credit code from us. The balance never expires: it carries over from period to period and when you change plan.
- Then new tests stop. Once the credit and the balance are both used up (counting what the sandboxes running now have cost so far), new tests on the platform executor or in a sandbox can't start and the platform's models stop, until the credit comes back, you top up or you redeem a code.
There is no overage: nothing is charged beyond your plan's fee and the top-ups you choose to make. A sandbox already running finishes its run; what it costs past the limit comes off your next top-up. Top-ups and credit codes work on Free, Pro and Ultra (and on Prepaid). The balance only lifts the credit limit: every other limit below stays. See top up and redeem a credit code.
Unit prices
Prices are in US dollars, as billed.
Sandboxes, per hour, by class. Counted per second from when the virtual machine is created until it is deleted, at least 1 minute per virtual machine. x86 and ARM cost the same.
| Class | Per hour |
|---|---|
| Small | 8.75¢ |
| Standard (default) | 17.5¢ |
| Large | 35¢ |
| Extra large | 67.5¢ |
| 2X large | $1.50 |
| GPU (coming soon) | $1.98 |
A custom spec costs what its size adds up to, counted the same way.
Models, per million tokens, for the tokens actually used: the model's list price in US dollars plus 30%. So $1 of model bill is billed as $1.30. Each project uses one of these, chosen in its header (see the platform's models).
| Model | Input | Cached input | Output |
|---|---|---|---|
| Gemini 4 Argon (Strongest · slower, the default) | $5.20 | $0.26 | $26.00 |
| GPT-6.1 Sol (Strong · faster) | $2.60 | $0.13 | $13.00 |
| Gemini 3.8 Flash (Balanced) | $1.95 | $0.195 | $9.75 |
| GPT-6 Luna (Economy) | $0.13 | $0.013 | $0.65 |
Usage is billed exactly, token by token. Cached input is the part of a prompt the provider serves from its cache. A model's thinking counts as output tokens.
Storage: 12.5¢ per GB per month, charged by the day.
Traces uploaded: free for now (metered, see what is metered).
The AI Gateway: a call on a platform model is billed like any platform-model usage above (list price plus 30%); a call with your own provider key (x-provider-key) costs nothing on our side.
An example
A 30-minute run on a Standard sandbox, whose agent uses 1 million input tokens and 0.2 million output tokens through the platform, on each of the project's models:
| Gemini 4 Argon | GPT-6.1 Sol | Gemini 3.8 Flash | GPT-6 Luna | |
|---|---|---|---|---|
| Sandbox: 0.5 hours × 17.5¢ | 8.75¢ | 8.75¢ | 8.75¢ | 8.75¢ |
| Model input: 1 million | $5.20 | $2.60 | $1.95 | 13¢ |
| Model output: 0.2 million | $5.20 | $2.60 | $1.95 | 13¢ |
| Total | about $10.49 | about $5.29 | about $3.99 | about $0.35 |
When the platform judges the run, the judge costs extra, on the same model. Input the provider serves from its cache costs less. On the Free plan, the run on GPT-6 Luna uses about 7% of the month's $5; on Pro, the run on GPT-6.1 Sol about 26% of the period's $20.
What is metered
These are measured and appear on your usage page and invoice:
| Item | Unit | Notes |
|---|---|---|
| Sandbox time | Hours, per class or custom spec | Counted per second from when the virtual machine is created until it is deleted, with a minimum of one minute per virtual machine. Pre-runs ("Check once") use sandbox time too. One price per class, whether it runs on x86 or ARM; a custom spec is priced by its size. A virtual machine that never reached the platform (it did not start up, or was stopped before it did) is not charged. |
| Judge model | Usage | The judge model grading replies and outcomes: in runs, in scorers that ask a judge (an SDK experiment's platform scorers, scorers added to an experiment, "Try it", calibration), in the Playground's scorers, and in online scoring (see the platform's models). |
| Platform models (AI under test) | Usage | Calls to one of the platform's models through the AI Gateway without your own key, and the Playground's prompt columns; a chat AI you test on a platform model instead of your own API and key; and the model calls of an agent in a repository or image project with no OPENAI_API_KEY in its secrets (see your agent's model), or on a local test runner with no OPENAI_API_KEY (and no OPENAI_BASE_URL) on that machine. |
| Assistant | Usage | The in-app assistant and the platform AI's other steps for a project (drafting tests, "Generate rows with AI", "Let AI finish and check", automatic approval, diagnosis, the issues it finds and the like), on the project's model. |
| Storage | GB-days | Run bundles and evidence kept in the platform. |
| Traces uploaded | GB, with the number of spans | Traces sent through the SDK, OpenTelemetry or the AI Gateway, measured as sent. Metered and shown on the usage page ("Traces uploaded"), but not charged for now. |
Not metered by us:
- Your own model calls. The agent under test, your app calling its provider directly or through the AI Gateway with
x-provider-key, a task in an SDK Eval, and a coding AI you connect use your own model keys; you pay your provider directly. The exceptions are metered as above: a call on a platform model through the Gateway or the Playground, a chat AI on a platform model, and an agent in a repository or image project with noOPENAI_API_KEYin its secrets, or on a local test runner with none on that machine, whose model calls the platform answers. - Scorers that don't ask a judge. Rules, code scorers and trajectory matching cost nothing.
- Local test runners. Tests on your own machine use no sandbox time (the judge model, and a platform model answering the agent, are metered as above).
- Embeddings for similarity checks. The platform's embedding model, used by
similarandanswer_relevance, isn't billed.
What the platform runs again because of its own problem (re-runs caused by a platform error, the fill-in run after a sandbox was lost part way, the lost sandbox's time that left no result) is metered and shown on the usage page as usual, but not charged. See the platform's problem isn't charged.
The platform's models
These are models the platform calls with its own accounts on Microsoft Azure and Google Cloud, so you need no API URL or key of your own. Each project uses one, chosen in its header next to its name ("Strongest · slower", "Strong · faster", "Balanced" or "Economy", or "Follow the organization default"). That model judges the project's runs, does the platform AI's work for the project and answers the model calls of an agent with no OPENAI_API_KEY (your agent's model). It is also the starting choice for a new chat AI on a platform model. See Models.
| Model | Tier | Input | Cached input | Output |
|---|---|---|---|---|
| Gemini 4 Argon | Strongest · slower (the default) | $4 | $0.20 | $20 |
| GPT-6.1 Sol | Strong · faster | $2 | $0.10 | $10 |
| Gemini 3.8 Flash | Balanced | $1.50 | $0.15 | $7.50 |
| GPT-6 Luna | Economy | $0.10 | $0.01 | $0.50 |
These are the models' list prices in US dollars per million tokens, for reference. What you are billed is in the unit prices above: the list price plus 30%. Azure charges more above a long-context threshold, but the platform's calls stay far below it and are billed at the short-context price. The estimate before a run is in US dollars as billed and includes what a platform-model chat AI will cost. A run stops at its spending limit (below).
A chat AI built earlier on gpt-5-mini or DeepSeek-V4-Pro keeps that model and is billed at its price: $0.325 / $2.60 and $2.262 / $4.524 per million input / output tokens as billed. These two are no longer offered for new chat AIs.
Sandbox classes
The class sets the size of the virtual machine for a cloud run. Standard is the default; a project can choose another under "Settings" → "Sandbox". Every class, and a custom spec, is available on every plan, Free included.
| Class | x86 machine | ARM machine | vCPUs | Memory | Disk | Per hour | Suits |
|---|---|---|---|---|---|---|---|
| Small | e2-medium | n4a-standard-1 | 2 shared (x86) / 1 (ARM) | 4 GB | 30 GB | 8.75¢ | Light agents that only call external model APIs |
| Standard (default) | e2-standard-2 | n4a-standard-2 | 2 | 8 GB | 30 GB | 17.5¢ | Most agents |
| Large | e2-standard-4 | n4a-standard-4 | 4 | 16 GB | 50 GB | 35¢ | Agents with a database and several tool backends |
| Extra large | e2-standard-8 | n4a-standard-8 | 8 | 32 GB | 100 GB | 67.5¢ | Small local models or heavy dependencies |
| 2X large | e2-standard-16 | n4a-standard-16 | 16 | 64 GB | 200 GB | $1.50 | Large builds, several heavy services, or local models that need more memory |
| GPU (coming soon) | g2-standard-8 | None | 8, and one GPU with 24 GB of GPU memory | 32 GB | 100 GB | $1.98 | Local models that need a GPU |
On ARM a vCPU is a full core; on x86 it is a hyperthread. The GPU class is shown greyed out ("coming soon") under "Settings" → "Sandbox" until the platform's GPU image is ready and has passed its security checks; then the platform switches it on.
Custom spec
When no class fits, choose "Custom…", the last option under "Settings" → "Sandbox" → "Class", and set the size yourself: cores (an even number from 2 to 80), memory (2 to 640 GB), disk (30 to 2,000 GB) and GPUs (none, 1, 2 or 4, with 24 GB of GPU memory each). It is there for sizes no class has, such as 200 GB of memory, and works on every plan, Free included. A custom spec runs in London.
The platform gives you the cheapest machine at least that big. When that is more than you asked for, a line under the fields says what you get, for example "Actually allocated: 26 cores · 200 GB memory · 30 GB disk", beside the price, "Price: about $3.64/hour".
- Without a GPU: the cores are the larger of the cores you asked for and the memory ÷ 8, rounded up to an even number (a core comes with at most 8 GB, and more cores cost less than extra memory); the memory is the larger of the memory you asked for and 2 GB per core. ARM follows the same rule up to 64 cores and 512 GB; for more, choose x86.
- With GPUs (x86 only): the smallest machine below with that many GPUs that covers the cores and memory you asked for. Anything bigger is refused.
The price per hour is the machine plus the disk, billed like a class: per second, at least 1 minute per virtual machine.
| Per hour | x86 | ARM |
|---|---|---|
| Per core | 7.467¢ | 6.3346¢ |
| Per GB of memory | 0.8475¢ | 0.7208¢ |
| Per GB of disk | 0.025¢ | 0.025¢ |
| GPUs | Cores | Memory | Machine per hour |
|---|---|---|---|
| 1 | 4 | 16 GB | $1.61 |
| 1 | 8 | 32 GB | $1.944 |
| 1 | 12 | 48 GB | $2.278 |
| 1 | 16 | 64 GB | $2.612 |
| 1 | 32 | 128 GB | $3.95 |
| 2 | 24 | 96 GB | $4.556 |
| 4 | 48 | 192 GB | $9.112 |
The disk of a machine with GPUs is 0.0328¢ per GB per hour. GPUs in a custom spec open together with the GPU class; until then a spec with a GPU is refused with the same "coming soon" note.
Some examples, each with a 30 GB disk:
| Asked for | Allocated | Per hour |
|---|---|---|
| x86, 4 cores, 200 GB | 26 cores · 200 GB · 30 GB | about $3.64 |
| x86, 8 cores, 64 GB | 8 cores · 64 GB · 30 GB | about $1.15 |
| x86, 16 cores, 32 GB | 16 cores · 32 GB · 30 GB | about $1.47 |
| 1 GPU, 16 cores, 64 GB | 16 cores · 64 GB · 1 GPU (24 GB) · 30 GB | about $2.62 |
The estimate before a run uses the custom spec's price.
Spending controls
| Control | Default | Status |
|---|---|---|
| The plan's credit each period | $5 a month on Free, $20 on Pro, $200 on Ultra; then the credit balance (top-ups and credit codes); once both are used up (counting the sandboxes running now), new tests on the platform executor or in a sandbox are refused and the platform's models stop, until the credit comes back, a top-up or a credit code | In place |
| Monthly spending cap (Enterprise) | None until the owner sets one; at the cap, new tests on the platform executor or in a sandbox are refused and the platform's models stop, while sandboxes already running finish their run | In place |
| Sandboxes running at the same time, per organization | 2, within the plan's limit (1 on Free, 3 on Pro, 10 on Ultra); more wait in a queue | In place |
| Maximum run time | 120 minutes, within the plan's limit (60 on Free, 240 on Pro, 480 on Ultra) | In place |
| Judge model spending per run | About $6.50, or what is left of the credit and the balance, or of the spending cap, if less | In place |
| Platform model (AI under test) spending per run | About $6.50, or what is left of the credit and the balance, or of the spending cap, if less (shared with the judge) | In place |
Agent model spending per run (a sandbox agent with no OPENAI_API_KEY) | About $6.50, or what is left of the credit and the balance, the spending cap or the prepaid balance if less; at the limit the agent's model calls are refused and the run stops after the attempt in progress, with a partial report | In place |
| Assistant spending per organization per day | $6.50 on Free, $13 on Pro, $65 on Ultra; none while new tests are refused (the credit and balance, spending cap or prepaid balance used up, the subscription lapsed, the organization paused), and the same goes for automatic review and generating attacks. A top-up or a credit code doesn't raise it; write to admin@nice2.io for more | In place |
| Sandbox hours per month | None, unless an owner sets a limit in the organization policy; new runs are refused beyond it, and sandboxes still running are stopped after the attempt in progress | In place |
| Online scoring, per rule per day | $5 by default, set on each rule ($0.01 to $10,000); at the cap the rule stops until 00:00 UTC | In place |
| Formal tests a dev machine AI connection starts, per day | $5 by default, set on each connection ($0 to $1,000, or no daily limit: the default on a repository or image project, where only the organization's own credit and caps apply). A test holds what it's expected to cost as it starts (from the project's runs so far), and the platform's models stop at what is left of the day while it runs; in a sandbox it also holds its sandboxes for the longest run. A cap set or lowered while a test runs to below what's used today stops it at its next model call. A test that doesn't fit isn't started | In place |
| AI Gateway calls | 600 a minute per organization; platform-model calls stop when the credit and balance (or the spending cap) are used up | In place |
Organization owners can change the number of sandboxes at once, the run time and the monthly sandbox hours in the organization settings, within what their plan allows. The estimate before a run says when it would go past a per-run limit. What your organization has used this month, by project and by day, is under "Organization" → "Usage". The billing dashboard under "Organization" → "Billing" has the plan, the balance with top-ups and credit codes, the period's spend, the limits with how far along each is, the invoices, subscribing and changing plan.