Pricing Calculator

This worksheet turns public list prices and your own measured usage into a monthly estimate. It deliberately avoids fixed message counts and predictions of plan exhaustion, because current plans meter work by model, tokens, context, effort, and execution surface.

Step 1: Record Fixed Subscription Prices

Individual Plans

Product	Lower Paid Tier	Higher-Usage Tier	Highest Public Tier
Cursor	Pro — $20/month	Pro+ — $60/month	Ultra — $200/month
Claude with Claude Code	Pro — $20/month or $200/year	Max 5x — $100/month	Max 20x — $200/month
ChatGPT with Codex	Plus — $20/month	Pro 5x — $100/month	Pro 20x — $200/month

Named Team Seats

Workspace	Monthly Seat	Annual Seat Equivalent	Minimum / Notes
Cursor Teams Standard	$40	$32	Central billing and admin controls
Cursor Teams Premium	$120	$96	Five times Standard included usage
Claude Team Standard	$25	$20	Five-member minimum; Claude Code included
Claude Team Premium	$125	$100	Can be mixed with Standard seats
ChatGPT Business standard seat	$25	$20	Two-seat minimum; baseline Codex included
Enterprise	Custom	Custom	Use the signed quote, not a public-plan estimate

Step 2: Capture Variable Usage

Use one complete billing cycle where possible.

Input	Where to Find It	Unit
Cursor on-demand spend	Cursor usage dashboard	USD/month
Cursor first- and third-party pool consumption	Cursor team/individual dashboard	Vendor-reported usage
Claude usage credits or bundles	Claude Settings → Usage	USD/month
Claude API-key spend	Claude Console or cloud provider	USD/month
Codex purchased credits	Codex Settings → Usage	Credits and purchase cost
ChatGPT Business/Enterprise credit spend	Workspace Billing/Usage	Credits and USD/month
Separate CI, SDK, review, or compute costs	Provider invoices	USD/month

Do not convert “requests” into dollars with a universal multiplier. A request can range from a short cached turn to a long multi-agent run.

Step 3: Apply the Formula

Individual

monthly total
= fixed subscriptions
+ measured usage credits
+ measured on-demand usage
+ separately billed API/SDK/automation usage
+ tax and currency adjustments

Team

monthly team total
= standard seats × standard rate
+ premium seats × premium rate
+ workspace credits or on-demand usage
+ separate API/automation/review spend
+ tax, support, and contracted platform fees

Current Included-Usage Reference

Plan	Subscription	Published Third-Party API Pool
Pro	$20	$20 plus first-party/bonus capacity
Pro+	$60	$70 plus first-party/bonus capacity
Ultra	$200	$400 plus first-party/bonus capacity

Cursor Teams Standard and Premium use separate first-party and third-party pools. Premium provides five times Standard total included usage at three times the seat price. Check the live dashboard for each pool rather than estimating a fixed number of prompts.

Current Codex Credit Rate Card

Most Plus, Pro, Business, and Enterprise-family customers use these credits per 1M tokens:

Model	Input	Cached Input	Output
GPT-5.6 Sol	125	12.5	750
GPT-5.6 Terra	62.5	6.25	375
GPT-5.6 Luna	25	2.5	150

task credits
= input MTok × input credit rate
+ cached-input MTok × cached-input credit rate
+ output MTok × output credit rate

Fast mode uses separate rates. A small legacy Enterprise cohort may still have a message-based card; use the rate card displayed for that workspace.

API and On-Demand Model Rates

These are list rates per 1M tokens, useful when a subscription switches to usage credits or when you authenticate with an API key.

Provider	Model	Input	Output	Pricing Note
OpenAI	GPT-5.6 Sol	$5	$30	Cache writes and reads have separate rates
OpenAI	GPT-5.6 Terra	$2.50	$15	Long inputs can trigger higher rates
OpenAI	GPT-5.6 Luna	$1	$6	Lowest-cost GPT-5.6 tier
Anthropic	Claude Fable 5	$10	$50	Standard API / usage-credit rate
Anthropic	Claude Opus 4.8	$5	$25	Standard API / usage-credit rate
Anthropic	Claude Sonnet 5	$2	$10	Introductory through Aug 31, 2026; then $3/$15
Cursor	Composer 2.5 Standard	$0.50	$2.50	First-party list rate
Cursor	Composer 2.5 Fast	$3	$15	Default Composer variant when selected
Cursor	Grok 4.5 Standard	$2	$6	First-party list rate
Cursor	Grok 4.5 Fast	$4	$18	Faster variant

Example Token Arithmetic

For an illustrative request with 5,000 uncached input tokens and 2,000 output tokens:

cost = (5,000 / 1,000,000 × input rate)
     + (2,000 / 1,000,000 × output rate)

Model	Illustrative Token Cost
GPT-5.6 Sol	$0.085
GPT-5.6 Terra	$0.0425
GPT-5.6 Luna	$0.017
Claude Fable 5	$0.15
Claude Opus 4.8	$0.075
Claude Sonnet 5 at introductory rates	$0.03

This excludes cache writes, tools, search, computer use, fast/priority processing, and agent overhead. It is arithmetic, not an average request forecast.

Illustrative Budget Scenarios

Scenario A: One Developer, One Tool

Fixed plan: Cursor Pro = $20
Observed on-demand usage this billing cycle = $18
Separate API/automation spend = $7

Illustrative monthly total = $20 + $18 + $7 = $45

The same formula applies to Claude or ChatGPT/Codex. Substitute the selected plan fee and the observed credits or API spend.

Scenario B: One Developer, Three Tools

Cursor Pro = $20
Claude Pro = $20
ChatGPT Plus with Codex = $20
Measured variable usage = $VARIABLE

Monthly total = $60 + $VARIABLE

This is a redundancy budget, not a recommendation. Track which tool produces accepted work before renewing all three.

Scenario C: Five-Person Managed Workspace

Option	Fixed Monthly	Fixed Annual Equivalent	Variable Component
Cursor Teams Standard	$200	$160/month	On-demand usage
Claude Team Standard	$125	$100/month	Optional usage credits
ChatGPT Business	$125	$100/month	Optional workspace credits

For mixed Standard/Premium seats, multiply each seat type separately. Never represent a shared consumer account as a cost-saving option.

Scenario D: Enterprise

Do not invent a per-seat Enterprise number. Request a quote and capture:

Fixed platform and seat fees
Included credits or token commitment
Overage and model rate card
Minimum term and true-up rules
SSO, SCIM, retention, residency, audit, and support charges
Sandbox, compute, review, and automation charges

ROI Worksheet

Enter measured inputs:

MONTHLY_TOOL_COST = subscriptions + variable usage + allocated admin cost
LOADED_HOURLY_RATE = salary + benefits + overhead per productive hour
MEASURED_HOURS_SAVED = observed monthly reduction in comparable work

BREAK_EVEN_HOURS = MONTHLY_TOOL_COST / LOADED_HOURLY_RATE
GROSS_VALUE = MEASURED_HOURS_SAVED × LOADED_HOURLY_RATE
NET_VALUE = GROSS_VALUE - MONTHLY_TOOL_COST
ROI_PERCENT = (NET_VALUE / MONTHLY_TOOL_COST) × 100

Pure Break-Even Arithmetic

Monthly Cost	$50/hour	$75/hour	$100/hour	$150/hour
$20	0.40 h	0.27 h	0.20 h	0.13 h
$60	1.20 h	0.80 h	0.60 h	0.40 h
$100	2.00 h	1.33 h	1.00 h	0.67 h
$200	4.00 h	2.67 h	2.00 h	1.33 h

The calculation says how much time would be required to break even. It does not prove the time was saved.

Review Checklist

Every person has a named, authorized seat
Current checkout or contract prices replace US list-price placeholders
Dashboard usage covers at least one representative billing cycle
Credits and API spend are not double-counted
Subscription usage is kept separate from API-key usage
Promotions are excluded from the long-term baseline
Enterprise estimates come from a quote
Productivity assumptions are labeled illustrative until measured
The model and rate-card date are recorded

Official Sources

Cursor: pricing, usage pools, Teams seats, Composer 2.5, and Grok 4.5
Anthropic: plan comparison, Team pricing and billing, usage credits, and API pricing
OpenAI: ChatGPT pricing, Codex access by plan, Codex rate card, Business billing, and GPT-5.6 API pricing