In our first year we priced a 6,000-hour teleoperation program the way most of this market still prices: by the raw hour. We hit our quoted rate and still broke the client’s budget model, because 22 percent of captured episodes failed their acceptance spec and nobody’s plan had funded the recollection. We rebuilt our cost model around that miss, and this guide is the rebuilt model, published.
The mistake was possible because robot training data has no commodity unit yet. An “hour” of data can mean a raw teleop stream with 30 percent unusable episodes, or a QA-passed, annotated, deduplicated hour that trains a policy. Those two hours differ in cost by 2x or more, and vendors quietly quote whichever one makes their number look better.
So here is the thesis this guide argues from the first table to the last: the only honest unit for pricing robot training data is cost per usable hour, and every quote you receive should be converted into that unit before you compare anything. To make the conversion possible, you will get our first-hand cost-per-hour benchmarks for teleoperation, egocentric human video, and multi-view exocentric capture; rig capex figures anchored to public hardware like ALOHA and UMI; the QA rejection math that separates raw hours from usable hours; and a worked budget for a 10,000-hour VLA data program.
DexSet collects egocentric, exocentric, teleoperation, mono, and stereo data for physical AI teams. We run these rigs, staff these operators, and eat these QA rejections every week. Every number below is either our own operating benchmark or a cited public source.
TL;DR: Robot Training Data Costs at a Glance
- Teleoperation data: $28 to $60 per raw hour (rig amortization + operator + QA), based on DexSet benchmarks.
- Egocentric human video: $15 to $40 per hour, the cheapest scalable modality.
- Multi-view exocentric capture: $20 to $50 per hour depending on camera count and calibration load.
- Annotation passes: $8 to $25 per hour extra, on top of any capture modality.
- Rig capex: ~$20k for an ALOHA-style bimanual station (per the ALOHA paper), ~$32k for Mobile ALOHA, under $1k per UMI-style handheld gripper by our build estimates.
- QA rejection runs 10 to 30 percent in our pipelines, so always budget on cost per usable hour, not raw hour.
- Public scale references: Open X-Embodiment aggregates 1M+ trajectories across 22 embodiments; DROID contains 76k episodes.
What Do Robot Training Data Costs Actually Include?
Robot training data cost is the fully loaded price of producing one hour of demonstration data that a robot learning pipeline can actually consume, covering hardware amortization, operator or collector labor, QA review, annotation, and delivery infrastructure. Most published debates skip half of these line items, which is why budgets built from a single “per hour” quote fall apart in month two.
A defensible cost model has five layers:
- Capture hardware (capex). Teleop stations, headsets, camera arrays, grippers. Amortized over 12 to 24 months of use.
- Collection labor (opex). Teleoperators, camera-wearing collectors, scene setup staff. Usually the largest single line.
- QA and curation (opex). Human review, automated checks, rejection and recollection. The most commonly omitted layer.
- Annotation (opex). Language instructions, segmentation, keyframes, success labels. Priced per pass.
- Infrastructure (opex). Storage, upload bandwidth, format conversion, dataset versioning.
When a vendor quotes you a single number, ask which of these five layers it covers. In our experience the quoted number usually covers layers 1 and 2 and quietly excludes 3 through 5, which add 30 to 80 percent on top.
Core Modalities and What Each One Costs
A data modality is the combination of sensor viewpoint and control method used to produce demonstrations: teleoperation, egocentric human video, exocentric multi-view capture, and their mono or stereo variants. Each modality has a distinct cost structure because each one shifts spend between hardware, labor, and QA differently.
Teleoperation Data: $28 to $60 per Hour
Teleoperation data is demonstration data produced by a human directly controlling a robot, typically through a leader-follower arm setup or a VR interface, so the recorded actions are executable robot trajectories. It is the gold standard for imitation learning and VLA post-training because actions come out in the robot’s own action space, but it is also the most expensive modality per hour.
Our benchmarks across bimanual manipulation programs:
- Rig amortization: $4 to $9 per hour (a $20k to $32k station amortized over 18 months of two-shift use, including maintenance and spare grippers).
- Operator labor: $18 to $38 per hour depending on region, task dexterity, and whether the task needs trained specialists (cable routing and garment handling sit at the top of that range).
- QA overhead: $6 to $12 per hour, covering episode review, rejection, and partial recollection.
Total: $28 to $60 per raw teleop hour. Long-horizon mobile manipulation lands at the top of the range; tabletop pick-and-place with experienced operators lands at the bottom.
The entity chain matters here: teleoperation feeds imitation learning methods like ACT, which the ALOHA project introduced, and imitation learning at scale is what current VLA models are built on. The ALOHA paper (Zhao et al., “Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware,” https://arxiv.org/abs/2304.13705) demonstrated that a roughly $20k bimanual rig could produce data good enough for fine manipulation, which reset industry assumptions about capture hardware pricing.
Egocentric Human Video: $15 to $40 per Hour
Egocentric data is first-person video captured from head-mounted or body-mounted cameras while a human performs tasks with their own hands, giving models human-level dexterity examples without any robot in the loop. It is the cheapest modality to scale because the “rig” is a wearable and the collector is doing a task they already know how to do.
Our cost structure:
- Hardware amortization: $1 to $4 per hour. Headsets and head-mounted cameras cost $300 to $3,500 and survive thousands of capture hours.
- Collector labor: $10 to $26 per hour.
- QA overhead: $5 to $10 per hour. Egocentric QA is dominated by motion blur, gaze drift, and occlusion checks.
Total: $15 to $40 per hour. The catch is the embodiment gap: human hands are not robot grippers, so egocentric data usually pretrains representations rather than directly supervising actions. Datasets like Ego4D and EgoExo4D (https://arxiv.org/abs/2311.18259) established the research value of this modality; the commercial question is purely about cost-effective volume.
Multi-View Exocentric Capture: $20 to $50 per Hour
Exocentric data is third-person video captured from fixed or mobile external cameras observing a task from multiple calibrated viewpoints, which gives models scene context and cross-view consistency that a single egocentric stream cannot. Cost scales with camera count and, more painfully, with calibration and synchronization labor.
Our benchmarks: $20 to $50 per hour for 3 to 8 synchronized views, including calibration checks at every scene change. Stereo pairs add roughly 15 to 25 percent over mono at the same view count because of the extra calibration and QA burden, but they buy you metric depth, which matters for manipulation policies.
Annotation: $8 to $25 per Hour, on Top of Everything Above
Annotation cost is the incremental price of adding structured labels to captured data: language instructions, subtask segmentation, success and failure flags, object masks, or keyframe tags. It is always additive to capture cost, and it is where “cheap” datasets quietly become expensive.
Typical per-pass pricing from our pipelines:
- Language instruction labeling: $8 to $12 per data hour
- Subtask segmentation: $10 to $16 per data hour
- Dense object masks or contact annotation: $18 to $25 per data hour
Comparison Table: Cost per Hour by Modality
| Modality | Raw cost/hour (DexSet benchmark) | Hardware amortization share | QA rejection rate | Best suited for |
|---|---|---|---|---|
| Teleoperation (bimanual) | $28 to $60 | $4 to $9 | 10 to 25% | VLA post-training, imitation learning |
| Egocentric human video | $15 to $40 | $1 to $4 | 15 to 30% | Representation pretraining, hand priors |
| Exocentric multi-view (3 to 8 cams) | $20 to $50 | $3 to $7 | 10 to 20% | Scene understanding, cross-view learning |
| Stereo add-on (vs mono) | +15 to 25% | +$1 to $2 | +2 to 5 pts | Depth-dependent manipulation |
| Annotation pass (language) | +$8 to $12 | n/a | n/a | Instruction-following VLAs |
| Annotation pass (dense masks) | +$18 to $25 | n/a | n/a | Grasp and contact modeling |
Rig Economics: Capex Benchmarks You Can Verify
Rig capex is the upfront hardware cost of a capture station before a single hour of data exists, and it is the number that determines whether building in-house ever beats buying data. The public record here is unusually good, so you do not have to trust vendor hand-waving.
| Rig | Approx. capex | Source | Notes |
|---|---|---|---|
| ALOHA bimanual teleop station | ~$20,000 | ALOHA paper, https://arxiv.org/abs/2304.13705 | Leader-follower arms, cameras, frame |
| Mobile ALOHA | ~$32,000 | Mobile ALOHA paper, https://arxiv.org/abs/2401.02117 | Adds mobile base for whole-body tasks |
| DexSet production teleop cell | $20,000 to $32,000 | First-hand DexSet build costs | ALOHA-class arms plus industrial cameras, lighting, sync hardware |
| UMI handheld gripper | Under $1,000 per unit (our build estimate) | UMI paper, https://arxiv.org/abs/2402.10329 | Portable gripper with wrist camera; no robot needed at capture time |
| Egocentric headset kit | $300 to $3,500 | Consumer/enterprise hardware pricing | Camera glasses to mixed-reality headsets |
Two practical lessons from running these rigs:
First, capex is rarely the problem. A $26k teleop cell running two shifts amortizes to under $9 per hour within 18 months. Labor and QA dominate every mature program we run.
Second, UMI-style handheld grippers changed the low end of the market. Because the capture device is a portable gripper with a wrist camera rather than a full robot cell, collection can happen in real homes and kitchens at egocentric-like labor costs while still producing gripper-centric trajectories. The trade-off is a heavier post-processing and QA load to recover clean actions.
Cost per Usable Hour: The Number That Actually Matters
Cost per usable hour is the total program spend divided by the hours that survive quality assurance, and it is always higher than the quoted cost per raw hour. This is the single most important correction to apply to any vendor quote, including ours.
In DexSet pipelines, QA rejection runs 10 to 30 percent depending on modality and task difficulty. Episodes get rejected for dropped frames, desynchronized views, failed task completion, occluded end-effectors, or annotation mismatches. The math is unforgiving:
Usable-hour math. At $40 per raw teleop hour with a 25 percent rejection rate, your real cost is $40 / 0.75 = $53.33 per usable hour. A competitor quoting $36 per hour with an unmeasured 35 percent rejection rate is actually charging $55.38. The cheaper quote is the more expensive dataset.
| Quoted raw $/hr | Rejection rate | True cost per usable hour |
|---|---|---|
| $30 | 10% | $33.33 |
| $30 | 30% | $42.86 |
| $40 | 15% | $47.06 |
| $40 | 25% | $53.33 |
| $55 | 10% | $61.11 |
When you evaluate any provider, require three things in writing: the measured rejection rate on a comparable program, who pays for recollection of rejected episodes, and whether QA review labor is inside or outside the quoted rate. If a vendor cannot produce a rejection rate, they are not measuring quality.
Budgeting a Program: A Worked Example
A data budget is a forward plan that converts a target usable-hour count into total spend across capture, QA, annotation, and infrastructure. Here is a realistic model for a VLA team that needs 10,000 usable teleop hours with language annotation.
- Target: 10,000 usable hours
- Assumed rejection rate: 20 percent, so raw capture target = 12,500 hours
- Blended teleop rate: $42 per raw hour = $525,000 capture
- Language annotation at $10 per usable hour = $100,000
- Storage, versioning, delivery at roughly 4 percent of capture = $21,000
- Total: ~$646,000, or $64.60 per usable annotated hour
For scale context, Open X-Embodiment pooled more than 1 million trajectories across 22 robot embodiments from 21 institutions (https://arxiv.org/abs/2310.08864), and DROID contains 76,000 episodes collected across 52 buildings (https://arxiv.org/abs/2403.12945). Those datasets exist because no single lab could afford to collect that volume alone, which tells you what the market already knows: collection cost, not model architecture, is the binding constraint on physical AI progress.
Build vs Buy: When Each One Wins
The build-vs-buy decision compares the fully loaded cost of standing up your own capture operation against a vendor’s cost per usable hour at your required volume and quality bar. Neither answer is always right; the crossover depends on volume, duration, and how much operational pain you can absorb.
Build wins when you need under roughly 2,000 hours of highly proprietary, robot-specific data, you already own the robots, and engineering time is genuinely available. Buy wins when you need volume and velocity: a vendor already amortized the rigs, trained the operators past the learning curve (operator throughput improves 30 to 50 percent over their first 200 hours in our programs), and built the QA tooling you would otherwise write from scratch. Most funded teams land on a hybrid: build one internal cell for rapid task iteration, buy production volume.
Case Study Proof: A Humanoid Foundation Model Team
A humanoid foundation model team came to us with a $400k data budget, a quoted competitor rate of $35 per hour, and a plan for 11,400 hours. The quote excluded QA review and carried no measured rejection rate. On a 200-hour pilot we measured 28 percent rejection against their own spec, which repriced the competitor dataset at $48.60 per usable hour before annotation.
We restructured the program: tightened the task spec to cut ambiguity-driven rejections, moved 30 percent of volume to egocentric capture for representation pretraining, and reserved teleop for post-training data. Result: 9,800 usable hours delivered inside the original budget, with rejection stabilized at 12 percent by week six. The lesson is not that our rate was lower. It is that cost per usable hour, measured on a pilot, is the only number that predicted their final spend.
Why Most Vendors Hide Pricing, and Why We Publish It
Hidden pricing is a deliberate market structure in which vendors quote deal by deal to maximize price discrimination, and it survives because buyers lack a shared benchmark. Large annotation-era incumbents built their margins on this asymmetry, and robot data inherited the habit.
We publish our ranges because the buyers we want, Heads of Data who run pilots and measure rejection rates, are exactly the buyers opaque pricing repels. Transparent ranges cost us the occasional overpriced deal and win us every buyer who has been burned before. You should treat any vendor’s refusal to publish even a range as information about how they expect the negotiation to go.
Free Download: The Robot Data Cost Model and RFP Scorecard
We packaged the math in this guide into two working documents: a cost model spreadsheet with editable assumptions for rejection rate, shift count, and amortization period, and a 24-question RFP scorecard covering the five cost layers, QA measurement, and recollection liability. Both are free, no email gate on the scorecard.
Related Reading
Frequently Asked Questions
How much does robot training data cost per hour?
Based on DexSet’s operating benchmarks: teleoperation runs $28 to $60 per raw hour, egocentric human video $15 to $40, and multi-view exocentric capture $20 to $50. Annotation adds $8 to $25 per hour per pass. Divide any quoted rate by (1 minus the rejection rate) to get the true cost per usable hour.
What does an ALOHA-style teleoperation rig cost?
The original ALOHA paper reports a bimanual rig built for roughly $20,000, and Mobile ALOHA extends it to whole-body mobile manipulation at roughly $32,000. Our production cells, with industrial cameras, lighting, and sync hardware added, land between $20,000 and $32,000.
What is a typical QA rejection rate for robot training data?
In our pipelines, 10 to 30 percent of raw episodes fail QA, depending on modality and task complexity. Well-specified tabletop teleop can hold near 10 percent; long-horizon mobile tasks and loosely specified egocentric capture push toward 30 percent.
Is it cheaper to build a data collection rig or buy data?
Building tends to win below roughly 2,000 hours of proprietary, robot-specific data when you already own robots and engineering time. Buying wins at volume because vendors have amortized rigs, trained operators, and existing QA tooling. Most teams run a hybrid.
Why is egocentric data cheaper than teleoperation data?
Egocentric capture uses wearable cameras and human hands, so hardware costs hundreds to a few thousand dollars and collectors perform familiar tasks at natural speed. Teleoperation requires a $20k to $32k rig plus a trained operator, and outputs executable robot actions, which is what you pay the premium for.
How big are today’s public robot datasets?
Open X-Embodiment aggregates more than 1 million trajectories across 22 robot embodiments, and DROID contains 76,000 episodes. Both are useful pretraining anchors, but most teams still need proprietary data matched to their own embodiment and tasks.
What should I ask a robot data vendor before signing?
Require the measured QA rejection rate on a comparable program, clarity on who pays for recollection, an itemized list of which cost layers the rate includes (hardware, labor, QA, annotation, infrastructure), and a paid pilot with your acceptance spec before any volume commitment.
Ready to price your program with real numbers?
Download the DexSet Robot Data Cost Model and RFP Scorecard, or book a 30-minute pricing walkthrough with our data operations team. We will run your task list through the same model we use internally and hand you the spreadsheet.
