Plans & Pricing

CodeCourier uses a bring-your-own-key model where the core platform is available to all users, and costs scale based on your actual usage of external AI and compute services. This page outlines the platform tiers, what each includes, and how pricing works for the services that power your AI workflows.

Platform Access

CodeCourier's platform access is structured around project and team capabilities rather than traditional per-seat subscription plans. All users get access to the core features:

• Sandbox creation and management
• Workflow builder with all pipeline types (single designer, designer-checker, custom pipeline, persona pipeline)
• Issue sessions and work chain execution
• Issue discovery sessions
• Persona creation and management
• Learning extraction and knowledge management
• Real-time sandbox chat interface
• Usage analytics dashboard
• Project API keys for programmatic access

Service Costs

Your actual costs are determined by the external services you consume. CodeCourier tracks usage across these services and displays aggregated costs in your project dashboard:

Anthropic models (Claude)

Per-1M-token rates in USD. Cache writes (cache_5m, cache_1h) and cache reads (cache_read) are billed separately from regular input. Rates verified against the Anthropic pricing page; current as of April 2026.

Anthropic prompt caching:writes are billed at 1.25× the input rate (5-minute cache) or 2.0× the input rate (1-hour cache); reads are billed at 0.10× the input rate. The 5-minute tier is the default and is appropriate for chained agent turns; the 1-hour tier is worth the higher write cost only when the same prefix is re-read many times across a long-running session.

OpenAI models (Codex / GPT-5.x)

OpenAI exposes a single cached_input rate covering the cached prompt prefix. Reasoning tokens (o-series, GPT-5.x with reasoning enabled) are billed at the regular output rate.

OpenAI cached_input:0.10× the input rate (90% discount on the cached prompt prefix). Identical magnitude to Anthropic cache reads.

Reasoning tokens (o-series, GPT-5.x with reasoning enabled, Claude extended thinking) are billed at the regular output token rate. They are tracked separately from visible output tokens in usage records under reasoningTokens so the dashboard can surface them when calibrating model selection.

OpenRouter / Gemini

Routed pricing depends on the underlying model. Rates flow through to usageCostRates with service: "openrouter" and the routedmodelOrTier identifier.

How we measure

Token counts come straight from each agent runtime's structured output stream - never sampled, never estimated. Four parsers normalize the provider-specific shapes into the unified breakdown (inputTokens, outputTokens, cacheCreation5mTokens, cacheCreation1hTokens, cacheReadTokens, reasoningTokens):

• Claude Code → --output-format stream-json, parsed by trigger/lib/parsers/claude-stream-json.ts.
• Codex CLI → codex exec --json, parsed by trigger/lib/parsers/codex-ndjson.ts.
• OpenCode → opencode run --format json, parsed by trigger/lib/parsers/opencode-ndjson.ts.
• Pi → native JSONL, parsed by lib/parsers/pi-jsonl.ts.

Each usageRecords row carries captureSource (which parser wrote it) and parserVersion (which schema version was current at capture time) so historical rows remain auditable after parser upgrades.

Sandbox Compute Costs

E2B sandbox costs are based on active VM uptime:

• Billed per second of active sandbox time
• Paused sandboxes may have reduced rates depending on your E2B plan
• Killed sandboxes stop accruing charges immediately

Background Job Costs

Trigger.dev costs are based on task execution time and compute resources. Most of the Trigger.dev cost is indirect -- the tasks primarily orchestrate E2B sandboxes and make API calls, so the bulk of the cost appears under the sandbox and AI model categories.

Cost Rate Configuration

CodeCourier stores cost rates in the usageCostRates table. Each rate record includes:

• service -- The service category (anthropic, openai, openrouter, e2b, trigger_dev, convex).
• rateType -- The specific metric (input_tokens, output_tokens, sandbox_hour, storage_gb_month).
• rateLabel -- Human-readable description.
• unit -- The billing unit (per_1M_tokens, per_hour, per_gb_month).
• costPerUnit -- USD cost per unit.
• modelOrTier-- Optional model or tier qualifier (e.g., "claude-sonnet-4", "hobby").
• isActive -- Whether this rate is currently active.

The system provides a seedDefaultRates mutation that populates the rates table with sensible defaults based on current published provider pricing. A syncMissingRates mutation adds new rate types introduced in platform updates and refreshes known stale default rows without overwriting unrelated customized rates.

Feature Comparison by Role

Within a project, features are gated by membership role:

Member

• View project sandboxes, runs, and workflows
• Launch sandboxes and trigger runs
• Send messages to sandboxes
• View usage analytics

Admin

Everything in Member, plus:

• Create, edit, and delete workflows
• Manage personas
• Configure project settings
• Invite and remove team members
• Manage provider API keys

Owner

Everything in Admin, plus:

• Delete the project
• Transfer ownership
• Manage project API keys
• Access cost rate configuration
• Full access to usage records and analytics

Upgrading and Downgrading

Since CodeCourier uses a bring-your-own-key model, upgrading your capabilities primarily means upgrading your accounts with the underlying service providers:

• More sandbox capacity -- Upgrade your E2B plan for higher concurrency limits and longer timeout allowances.
• Faster AI models -- Upgrade your Anthropic plan for higher rate limits and access to more powerful models.
• More background jobs -- Upgrade your Trigger.dev plan for higher task concurrency.

Within CodeCourier, you can scale by:

• Creating additional projects to organize work
• Adding team members to share the workload
• Building custom templates for specialized sandbox environments
• Creating sophisticated persona pipelines for multi-agent collaboration

Enterprise Options

For organizations with advanced needs, CodeCourier supports enterprise-grade features:

• Detailed usage attribution -- Per-user, per-persona, per-model cost tracking with the enterprise tracking fields in usage records.
• Custom cost rates -- Configure exact rates that match your negotiated provider pricing, overriding the default published rates.
• Project-level API keys -- Scoped programmatic access for CI/CD and automation pipelines.
• Role-based access control -- Three-tier permission model (owner, admin, member) with project-scoped access.
• GDPR compliance -- Consent management, data export, and right-to-deletion support built into the platform.
• Notification system -- Real-time notifications for run completions, failures, PR events, and team activity.

For organizations requiring custom deployment options, dedicated infrastructure, or additional compliance features, contact the CodeCourier team to discuss enterprise arrangements.

Cost Estimation

We don't ship a static estimator. Every project has a live Usage dashboard at /p/[projectId]/usage that shows actual cost, per-service breakdown, per-token-class breakdown (input, output, cache reads, cache writes, reasoning), and computed cache savings - recomputed on every new run from the same usageRecords rows that drive billing.

To get a reliable forecast, run a representative workflow once, open the Usage dashboard, and read the per-period totals directly. The same view exposes the cache savings card, which quantifies how much the prompt cache is offsetting your input spend over the displayed period.