Pricing and Billing

Public Pricing

TutorFlow uses a single platform billing contract. Public pricing is defined by API category and then, when needed, by request quality tier inside that category.

Today, only one public pricing category exists:

• evaluation

Within evaluation, each request can choose:

• fast -> $0.01 / evaluation
• standard -> $0.03 / evaluation
• advanced -> $0.05 / evaluation

This structure is deliberate. It lets TutorFlow add future categories such as course creation, test creation, or slide creation without inventing a separate pricing system for each new API surface.

Today, the backend exposes:

• workspace credit balances
• optional workspace planCode
• optional workspace billingMode
• internal credit top-up management
• per-request usage records
• evaluation-type-based metering
• caller-selectable tier on evaluation requests
• stored price snapshots on evaluation requests and usage records
• internal billing invoice aggregation for finalized usage
• internal billing invoice creation via POST /v1/platform/billing/invoices
• invoice status sync

It does not currently expose:

• automatic signup credit issuance as part of the API flow

What Counts As An Evaluation

An evaluation is a completed call to POST /v1/platform/evaluations.

The current backend records usage for each evaluation and can attach:

• input and output tokens
• provider cost
• internal credit cost
• pricing tier
• public price snapshot
• billable USD amount
• finalized billed USD amount
• billing status
• request metadata

Evaluation requests can now include a tier of fast, standard, or advanced. If omitted, TutorFlow derives a default tier from evaluationType.

The stored price snapshot also carries:

• category = evaluation
• a catalogKey such as evaluation.fast

This keeps the pricing contract extensible across future API categories.

Internal Credit Ledger

The current backend uses internal credits for metering and balance management.

Current evaluation weights:

• exact: 0 credits
• rubric_short_answer: 2 credits
• open_ended: 3 credits

Credits are an internal billing unit. They let TutorFlow support monthly included usage, enterprise discounts, and future pricing changes without changing the public API contract.

Credits are not currently exposed as a fixed public dollar conversion. They are used as an internal settlement mechanism beneath the public category-based pricing contract.

In the current MVP, self-serve platform workspaces purchase credits through the checkout page. The minimum purchase is $5 and the maximum is $5,000. Internal manually-created workspaces still start with creditBalance: 0 unless credits are added through internal management flows.

The current default tier mapping is:

• exact -> fast
• rubric_short_answer -> standard
• open_ended -> advanced

Billing Model

In the current MVP, workspaces maintain a credit balance. Usage records are captured per request and deducted from that balance.

Billing finalization can now pin a USD amount from the stored price snapshot into the usage ledger. This lets TutorFlow separate:

• internal balance deduction via creditCost
• commercial billing via billableAmountUsd and finalizedAmountUsd

The backend now supports two billing execution modes.

internal_invoice

This remains the default.

• usage deducts internal credits
• finalized usage stores billable and finalized USD amounts
• monthly or manual invoice drafts can be created internally
• a Stripe invoice can optionally be created from the internal invoice draft

stripe_metered

This is the new usage-based billing path.

• usage still deducts internal credits for TutorFlow's internal ledger
• finalized usage is also reported to Stripe billing meters by tier
• Stripe invoice items are not manually created by TutorFlow for these workspaces
• internal billing invoices still exist, but they act as audit statements rather than the source of Stripe charges

For Stripe metered billing, the backend expects:

• billingMode = stripe_metered
• a configured billing customer in TutorFlow's billing system

If a meter report fails, the backend stores the error on the usage record and a reconciliation scheduler retries unreconciled finalized usage.

Finalized usage can also be aggregated into an internal billing invoice for a time period. For internal_invoice workspaces, that invoice can optionally create an external invoice through TutorFlow billing.

When a Stripe invoice is created, the backend now emits separate invoice items by tier instead of collapsing all usage into a single undifferentiated line.

There is also a scheduler in the backend that closes older uninvoiced finalized usage into monthly billing invoice drafts, plus a reconciliation scheduler that retries failed or missing Stripe meter reports for stripe_metered workspaces.

This gives TutorFlow two commercial operating modes today:

• prepaid or internally-managed invoice billing through internal_invoice
• Stripe subscription billing through stripe_metered

New self-serve workspaces purchase credits through the TutorFlow checkout page ($5 minimum, $5,000 maximum). The purchased amount is added to the workspace balance as credits.

Buying Credits

Workspaces can purchase additional credits at any time through the dashboard:

curl -X POST https://api.tutorflow.io/v1/platform/dashboard/workspaces/WORKSPACE_ID/billing/purchase-credits \
  -H "Authorization: Bearer tf_platform_..." \
  -H "Content-Type: application/json" \
  -d '{
    "amountUsd": 50
  }'

The purchased amount is added to the workspace balance immediately.

Agents can also request a checkout page URL via POST /v1/platform/agent/billing/session, which returns a TutorFlow-hosted checkout page where the human operator chooses the amount and completes payment through Stripe.

Auto-Reload Credits

Workspaces can enable auto-reload to avoid service disruptions when their balance runs low. When the credit balance drops below a configured threshold, credits are automatically purchased using the saved payment method.

For example, setting autoReloadThresholdUsd: 10 and autoReloadTargetUsd: 50 means that when the workspace balance drops below $10, a $50 credit purchase is automatically triggered using the saved payment method.

Why We Do Not Price By Tokens

Token pricing is accurate for infrastructure providers, but confusing for most education teams. TutorFlow is positioned as an evaluation product, not a raw LLM router, so we bill on the user-facing unit of value.

Enterprise

Enterprise contracts are appropriate when you need:

• high monthly volume
• SLA and priority throughput
• custom rubric or model tuning
• procurement-friendly invoicing

Contact TutorFlow for enterprise pricing and minimum-commit agreements.