Pricing

Agent Pricing

Orion agent pricing has two components: model usage billed by input and output tokens, and tools billed at fixed dollar prices. Every response includes the final dollar cost directly:

Response Field	What It Tells You
`cost_dollars`	What you actually pay (after tier multiplier)
`standard_cost_dollars`	Baseline cost at standard tier
`savings_dollars`	Discount vs. standard (positive on `flex`)
`service_tier`	Which delivery tier was used
`mode_multiplier`	Multiplier applied (1.0, 0.5, or 1.8)

Model quality tiers

Choose the model quality tier based on your accuracy/speed tradeoff. This is independent of the service tier (which controls delivery/cost).

Tier	Model ID	When to Use
Fast	`vlmrun-orion-2:fast`	Speed and cost-efficiency. Lighter models, fastest processing.
Auto	`vlmrun-orion-2:auto`	Recommended default. Uses Fast tools, upgrades to Pro for complex tasks.
Pro	`vlmrun-orion-2:pro`	Maximum quality. More powerful models, higher cost, longer processing.

These quality tiers apply to both Orion-1 and Orion-2 model families.

How tools are billed

Agent tools fall into two billing categories:

Fixed-price tools: GPU/API tools with a fixed dollar price per unit (per image, per page, per second, or per call). These appear in the pricing table below.
Token-billed tools: LLM-backed tools (captioning, detection, document parsing, video analysis) billed by input/output tokens recorded on the per-span cost ledger. Their cost depends on the selected model tier and the number of tokens consumed.

Fixed-price tools have predictable costs. Token-billed tools vary with input complexity and the selected model tier.

Fixed-price tools

These tools have a fixed dollar price per unit:

Image

Priced per image.

Capability	Description	Fast	Pro
Segment	Object segmentation (GPU-backed)	$0.01	$0.02
Generate & Edit	Generate or edit images from prompts	$0.04	$0.24

Document

Priced per page.

Capability	Description	Fast	Pro
OCR & Layout	Extract text and detect page structure	$0.01	$0.04
Extract grounding / confidence	Orion-2 `document.extract` surcharge when `grounding` or `confidence` is enabled	$0.01	$0.01

Video

Priced per second (generated video).

Capability	Description	Fast	Pro
Generate & Edit	Generate video from text/image prompts	$0.15/sec	$0.40/sec

Standard video generation produces ~6 seconds. At Pro tier: $0.40/sec × 6s = $2.40.

Compute & Execution

Item	Fixed Price
`agent.execution` (base session cost)	$0.001/call
`compute.execution` (code sandbox)	$0.001/call

LLM orchestration

Every agent run includes LLM token costs for reasoning, tool dispatch, and response synthesis. Orchestration tokens are charged at the agent model’s rate:

Tier	Input (per 1M tokens)	Output (per 1M tokens)
Fast / Auto	$0.30	$2.50
Pro	$1.00	$10.00

A typical single-tool run adds approximately $0.01–$0.03 (Fast/Auto) or $0.03–$0.08 (Pro) in orchestration costs. Multi-step runs will be higher.

Media input pricing

Each image or document passed as input to the agent has a fixed per-element price:

Tier	Price per element
Fast / Auto	$0.01
Pro	$0.02

Token-billed tools

These LLM-backed tools bill by actual token usage rather than a fixed price. Their cost is determined by the selected tier’s input/output token rates and the usage recorded on the per-span cost ledger.

Tool	Category	Billing Basis
Caption & Tag	Image	LLM tokens
Detect, Point	Image	LLM tokens
UI Parsing	Image	Free
Document Parsing / Extract / VQA	Document	LLM tokens (+ $0.01/page when `grounding` or `confidence` is enabled on Orion-2 `document.extract`)
Caption, Summary & Transcribe	Video	LLM tokens

Token costs depend on the quality tier you select. See the token rates table below.

Token rates (USD per 1M tokens)

Token-billed tools bill at the same per-tier token rates as LLM orchestration. You pay per quality tier, not per model:

Tier	Input	Output	Cache Discount
Fast / Auto	$0.30	$2.50	10%
Pro	$1.00	$10.00	10%

Cache discount means cached/repeated input tokens cost 10% less. Costs scale with the number of tokens a tool consumes, so simple inputs are cheaper than complex ones.

vlm-1 model tiers

The vlm-1 model family is available on /v1/image/generate and /v1/document/generate routes with three quality tiers:

Model ID	Tier	Detail Level
`vlm-1:fast`	Fast	`lo`
`vlm-1` / `vlm-1:auto`	Auto (default)	`auto`
`vlm-1:pro`	Pro	`hi`

vlm-1 tier token rates (for domain API billing):

Tier	Input	Output	Cache Discount	Thinking
`vlm-1:fast`	$0.25	$1.50	10%	—
`vlm-1` / `vlm-1:auto`	$0.26	$1.56	10%	—
`vlm-1:pro`	$1.50	$9.00	10%	$9.00

Set the model via request.model:

response = client.document.generate(
    file="invoice.pdf",
    domain="document.invoice",
    model="vlm-1:pro",
)

Service tiers

The service tier controls delivery (routing, latency, queue priority) and scales the total run cost by a fixed multiplier. It is independent of the model quality tier (Fast/Auto/Pro).

Tier	Multiplier	Cost Effect	Best For
`standard` (default)	1.0×	Base USD price	General agent workloads.
`flex`	0.5×	50% of standard	Background agent runs, batch processing.
`priority`	1.8×	180% of standard	User-facing interactions needing lowest latency.

The multiplier applies to the total dollar cost (model tokens + all tool calls). For example, a $1.00 standard run costs $0.50 at flex and $1.80 at priority.

# Flex tier: 50% discount on total agent cost
response = client.agent.execute(
    name="my-orion-agent",
    inputs={...},
    service_tier="flex",
)
# response.usage.cost_dollars → effective cost
# response.usage.savings_dollars → amount saved

// Priority tier: 1.8x premium, lowest latency
const response = await client.agent.execute({
  name: "my-orion-agent",
  inputs: {...},
  serviceTier: "priority",
});

curl -X POST https://api.vlm.run/v1/agent/execute \
  -H "Authorization: Bearer $VLMRUN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-orion-agent",
    "inputs": {...},
    "service_tier": "flex"
  }'

How a run cost is calculated

The standard dollar cost is the sum of model-token usage, media inputs, and fixed-price tools:

model_cost = (
    uncached_input_tokens × input_rate
    + cached_input_tokens × cached_rate
    + output_tokens × output_rate
) ÷ 1,000,000

standard_cost_dollars = model_cost + media_cost + fixed_tool_cost
cost_dollars = standard_cost_dollars × mode_multiplier

Where:

model_cost includes Orion reasoning turns and token-billed tool usage at the selected model tier’s rates
media_cost is the fixed per-element price for input images and documents
fixed_tool_cost is the sum of fixed-price tools such as segmentation, generation, OCR, and sandbox execution
mode_multiplier is determined by the service tier: 1.0× standard, 0.5× flex, or 1.8× priority

Orion 2 per-span cost ledger

Orion 2 runs produce a per-span ledger that itemizes every billable action:

Span Type	Priced By	Example
`mllm`	Model tokens (input + cached + output)	One LLM reasoning turn
`execute_code`	Fixed price ($0.001/call)	One sandbox code execution
`tool` (fixed-price)	Fixed dollar price	`vlmrun.image.generate`, `vlmrun.image.segment`
`tool` (token-billed)	Model tokens consumed	`vlmrun.document.extract`, `vlmrun.video.caption`

The service-tier multiplier is applied once at the run level:

effective_cost = SUM(span.cost) × mode_multiplier

This gives full transparency into what drove the cost of each run.

Examples

1. Image segmentation + generation

Component	Type	Fast	Pro
Segment 3 objects	Fixed-price (3×)	$0.03	$0.06
Generate 1 image	Fixed-price (1×)	$0.04	$0.24
Input image	Media (1×)	$0.01	$0.02
LLM orchestration	Tokens (approx.)	~$0.01	~$0.05
Estimated total		~$0.09	~$0.37

LLM orchestration varies with prompt complexity. The cost_dollars field in the response shows the exact amount.

2. Storyboard: 5 images + 5 video clips (6s each)

Component	Type	Fast	Pro
Generate 5 images	Fixed-price (5×)	$0.20	$1.20
Generate 30s video	Fixed-price (30s)	$4.50	$12.00
LLM orchestration	Tokens (approx.)	~$0.05	~$0.15
Estimated total		~$4.75	~$13.35

For generation-heavy runs, tool costs dominate. LLM orchestration is a small fraction of the total.

3. 50-page document: OCR + LLM parsing

Component	Type	Cost (Fast)
OCR & layout (50 pp)	Fixed-price: $0.01/page	$0.50
Input document	Media (1×)	$0.01
Parse/extract data	Token-billed (LLM)	Varies by complexity
LLM orchestration	Tokens (approx.)	~$0.02–$0.05
Estimated total (Fast)		~$0.53–$0.56

For Pro tier, OCR is $0.04/page ($2.00 for 50 pages) plus higher LLM orchestration costs (~$0.05–$0.10).

4. Orion 2 code-mode run (flex tier)

This example shows the per-span ledger for a code-mode run at flex (0.5×):

Span	Type	Standard Cost
Planning turn	`mllm` (token-billed)	~$0.002
Code sandbox	`execute_code` (fixed-price)	$0.001
Generate image	`tool` (fixed-price)	$0.04
Final turn	`mllm` (token-billed)	~$0.001
Standard total		~$0.044
Flex total (0.5×)		~$0.022 (saves ~$0.022)

5. Video analysis: token-billed

Video captioning and transcription are token-billed. The cost depends on video length and the quality tier:

Tier	10-min video (approx tokens)	Estimated Cost
Fast / Auto	~5K input + ~2K output	~$0.007
Pro	~5K input + ~2K output	~$0.025

Math: Fast = 5K × $0.30/1M + 2K × $2.50/1M ≈ $0.007. Pro = 5K × $1.00/1M + 2K × $10.00/1M ≈ $0.025.Plus any fixed-price tool costs (such as generation) if applicable.

FAQ

What's the difference between fixed-price and token-billed tools?

Fixed-price tools (segmentation, image generation, video generation, OCR, sandbox execution) have predictable dollar prices per unit. Token-billed tools (captioning, detection, document parsing, video analysis) bill by the selected model tier’s input and output token rates.

What's the difference between Fast, Auto, and Pro?

Fast uses lighter, faster models and is best for prototyping and high-volume workloads. Auto (default) starts with Fast tools and upgrades to Pro for complex tasks. Pro always uses the most powerful models and is best for production quality.

How is the total run cost determined?

It’s the sum of model token costs (orchestration + token-billed tools), media input prices, and fixed-price tool charges. The response includes cost_dollars (effective amount after the service-tier multiplier) and standard_cost_dollars (baseline).

What is the per-span cost ledger?

Every billable action during a run is recorded as a span: each LLM turn, each sandbox execution, and each tool call. The total is the sum of spans, with the service-tier multiplier applied once at the run level. This gives you full visibility into cost drivers.

What about vlm-1 model tiers?

vlm-1 is available on image and document generation routes with three tiers: vlm-1:fast (lowest cost), vlm-1:auto (balanced, default), and vlm-1:pro (highest quality). Set via the model parameter.

Are utility tools free?

Yes. Image I/O, rotation, cropping, video trimming, document navigation, UI detection, and similar utilities are free.

Get Started

Agent Documentation

Learn about Orion agent capabilities and how to build with them.

Get Started

Capabilities

Guides - Doc AI

Guides - Image AI

Guides - Video/Audio AI

Guides - Fine-tuning

Misc

Agent Pricing

Model quality tiers

How tools are billed

Fixed-price tools

Image

Document

Video

Compute & Execution

LLM orchestration

Media input pricing

Token-billed tools

Token rates (USD per 1M tokens)

vlm-1 model tiers

Service tiers

How a run cost is calculated

Orion 2 per-span cost ledger

Examples

FAQ

Get Started

Agent Documentation

​Agent Pricing

​Model quality tiers

​How tools are billed

​Fixed-price tools

​Image

​Document

​Video

​Compute & Execution

​LLM orchestration

​Media input pricing

​Token-billed tools

​Token rates (USD per 1M tokens)

​vlm-1 model tiers

​Service tiers

​How a run cost is calculated

​Orion 2 per-span cost ledger

​Examples

​FAQ

​Get Started

Agent Documentation

Agent Pricing

Model quality tiers

How tools are billed

Fixed-price tools

Image

Document

Video

Compute & Execution

LLM orchestration

Media input pricing

Token-billed tools

Token rates (USD per 1M tokens)

vlm-1 model tiers

Service tiers

How a run cost is calculated

Orion 2 per-span cost ledger

Examples

FAQ

Get Started