Calibrate your sensor data in minutes
Automatic sensor calibration for robots and autonomous systems.
No targets, no scripted drive, no site visit — upload a recording of normal operation and get extrinsics back with a confidence score per sensor.
Full request/response examples are in the API quickstart below.
Real field names from an actual API result — see the quickstart below.
Get started
The sample is a 16 MB drive recording (CC0). Your own recording stays on your machine until you have paid for a calibration.
A 1° error puts objects half a metre from where they are
Extrinsics decide where every lidar point lands in your camera image. A 1° rotational error shifts a point 30 m away by ~0.5 m sideways — enough to paint a pedestrian's points onto the car beside them, corrupt every fused label your models train on, and mis-associate tracks. The damage is silent: perception degrades, and nothing tells you calibration was the cause. That is why every job here returns per-sensor error and confidence, not just a matrix.
Why targetless, and how it compares
Every route to lidar-camera extrinsic calibration asks something of you. Here is what each one asks.
| Deepen Calibrate | Traditional target-based calibration | |
|---|---|---|
| No calibration target required | Yes | No — checkerboard, ChArUco or AprilGrid required |
| Cloud-based, nothing to install | Yes — REST API, 4 calls | No — runs as a CLI on your machine |
| Per-sensor confidence & error reporting on every result | Yes | Not standardized — varies by vendor |
| Works with ROS1 .bag, ROS2 .db3 and .mcap, unmodified | Yes | Format support varies by tool |
| No target session or site visit required | Yes | No — requires a capture session with the target in view |
Compares Deepen Calibrate to traditional target-based calibration tools (checkerboard, ChArUco, AprilGrid). Describes categories of calibration software, not a specific vendor. Verified against public vendor documentation at time of writing.
How does pricing work?
Pay per calibration: $75 for a standard job (up to 2 sensors — e.g. a lidar-camera pair or two lidars — recordings up to 10 GB), or $250 for a complex job (multi-lidar / multi-camera rigs, larger recordings). Card checkout issues your API key immediately, and each purchase is one calibration credit. For sustained volume, $15,000/month gets unlimited calibrations with priority processing. A failed job refunds the credit automatically. See pricing for details.
What happens to my data?
With the hosted API, your recording is uploaded to Deepen's service to run the job — the file is stored, not inspected, until you call validate. If you need your data to never leave your own infrastructure, the AWS Marketplace path (coming soon) runs the same engine entirely inside your own VPC. For specifics on retention and deletion, contact us.
How accurate is it?
We don't publish one blanket accuracy number — every job returns a confidence score per sensor, quality flags, error stats, and a before/after overlay report with the seed-versus-recovered delta, so you can judge the result yourself instead of trusting a single figure. Run the free CLI first to catch anything likely to produce a low-confidence result.
What are the cost savings?
You skip the cost of a target rig or calibration bay, a scripted capture session, and a site visit — you calibrate from a recording you already have. Turnaround is 15–25 minutes versus roughly a business day for a typical vendor capture-and-review service, and pricing starts at $75 per calibration with no monthly commitment.
Two ways to run it, one engine
Both paths run the same validator and return the same result schema. Only the location changes.
Hosted API
Upload once. We run the job and return extrinsics plus a quality report. Nothing to provision.
- One key, no infrastructure on your side
- Same validated pipeline as the in-VPC path
- First result the same session you sign up
AWS Marketplace — runs in your VPC
The engine runs in your AWS account against your own S3 bucket and compute. Built for data-residency and export-control reviews.
- Runs entirely inside your own AWS account
- Fits data-residency and export-control requirements
- Same calibration engine, same result format
Works with the rosbags you already record
Same reader on both sides: the CLI and the API parse identical formats, and neither needs ROS installed.
Container formats
ROS1 .bag · ROS2 .db3 · ROS2 .mcap
Lidar
Velodyne, Ouster, Hesai, RoboSense point clouds — plus native support for raw Hesai packet data
Camera
Raw and compressed (JPEG/PNG) image topics
IMU
Standard IMU messages, used for motion excitation and initial extrinsics
Vehicle
CAN / vehicle-speed data for lidar–vehicle calibration
Calibration types
LiDAR–Camera and Multi-LiDAR run through the API today. The CLI also validates LiDAR–IMU and LiDAR–Vehicle bags. Ask us to run those.
Topics are classified by message type, not by name, so your existing driver or stack naming convention works as-is.
From upload to extrinsics: four API calls
The same checks deepen-bag-check runs locally are what validate your bag server-side — nothing is re-checked differently.
Multipart upload. The file is stored, not inspected, until you validate it.
curl -X POST https://targetless.deepen.ai/calibration/bags \
-H "X-Api-Key: $DEEPEN_API_KEY" \
-F "file=@drive.mcap"
# -> 201 Created
{
"bag_id": "bag_8f2c1a",
"status": "uploaded",
"size_bytes": 4831201280,
"container_format": null,
"created_at": "2026-07-28T18:04:11Z"
}
Returns the calibration types this bag is eligible for, and the reason each ineligible type failed.
curl -X POST "https://targetless.deepen.ai/calibration/bags/bag_8f2c1a/validate?calibration_type=lidar_camera" \
-H "X-Api-Key: $DEEPEN_API_KEY"
# -> 200 OK (trimmed)
{
"bag_id": "bag_8f2c1a",
"status": "warnings",
"container_format": "ros2_mcap",
"eligible_calibration_types": ["lidar_camera", "multi_lidar"],
"ineligible_calibration_types": [
{ "type": "lidar_vehicle", "reason": "no CAN/vehicle-speed topic found" }
]
}
Start a job for an eligible type. It runs async and returns a job id.
curl -X POST https://targetless.deepen.ai/calibration/bags/bag_8f2c1a/calibrations \
-H "X-Api-Key: $DEEPEN_API_KEY" \
-H "Content-Type: application/json" \
-d '{"calibration_type": "lidar_camera"}'
# -> 202 Accepted
{
"calibration_id": "calib_5b19",
"status": "queued",
"calibration_type": "lidar_camera",
"created_at": "2026-07-28T18:06:02Z"
}
Poll until succeeded, then read extrinsics, confidence, quality flags, error stats and a report link per sensor.
curl https://targetless.deepen.ai/calibration/calibrations/calib_5b19/result \
-H "X-Api-Key: $DEEPEN_API_KEY"
# -> 200 OK (trimmed)
{
"schema_version": "1.0",
"calibration_id": "calib_5b19",
"status": "succeeded",
"extrinsic_camera_coordinate_system": "ROS_REP_103",
"results": {
"camera_front_wide": {
"extrinsic_parameters": {
"roll": 0.31, "pitch": -1.02, "yaw": 89.87,
"px": 0.14, "py": -0.02, "pz": 1.31
},
"reference_frame": "lidar_roof",
"confidence": 0.94
}
},
"quality_flags": []
}
These calls run against the live API. Swap in the key you get at checkout. A failed job returns a structured error and refunds the credit automatically — you do not pay for a run that produced no extrinsics.
Check eligibility before you pay
deepen-bag-check reads your .bag, .db3 or .mcap on your own machine. No upload, no account, no ROS install. It is the same validator that gates every paid job, so a pass here is a pass there.
No recording at hand? Download the sample recording (16 MB, CC0) and run the command below on it as-is.
# install (pip install works too, inside a venv) pipx install deepen-bag-check # check a bag against a calibration type deepen-bag-check drive.mcap --for lidar-camera
Open source, Apache-2.0 — view the source on GitHub.
deepen-bag-check 1.0.0 — drive.mcap container: ros2_mcap status: WARNINGS (exit code 1) Topics: /sensor/camera/front_wide/image/compressed [camera_compressed] 20.0 Hz /sensor/lidar/roof/points [lidar] 10.1 Hz vendor=hesai Checks: [WARN] camera_info_present: no paired CameraInfo topic [PASS] pointcloud_field_schema: fields map cleanly (vendor=hesai) [PASS] motion_excitation: sufficient rotational excitation Eligible calibration types: lidar_camera, multi_lidar
What it checks
- Container format & schema — catches a corrupt or unsupported file before it becomes a confusing failure downstream
- Topic classification by message type, never by name
- Per-vendor point cloud field mapping, so mismatched intensity or ring fields don't surprise you later
- Camera intrinsics presence, sensor sync, coverage, and motion excitation
- Machine-readable JSON output for CI, or a human-readable report for a quick look
Start with a bag you already have
Check it free with the CLI. If it qualifies, one API key gets you extrinsics the same session.
Pay per calibration, or per month
Card checkout issues your API key immediately. Failed jobs are refunded as credits.
Standard calibration
1 calibration credit · up to 2 sensors (a lidar-camera pair, or 2 lidars) · recordings up to 10 GB.
- Pay per completed job, no monthly commitment
- Covers a lidar-camera or multi-lidar job today
- Re-run after every sensor swap or knock
Complex calibration
1 calibration credit · multi-lidar and multi-camera rigs · larger recordings.
- Pay per completed job, no monthly commitment
- Covers larger sensor counts & recording sizes
- Same hosted API, same result schema
Unlimited monthly
Flat rate, priority processing, direct line to the team. Built for bring-up and integration months.
- Flat monthly rate, no per-job billing
- No per-job accounting during bring-up
- Priority processing and a direct line to the team
Enterprise & AWS Marketplace
Private offers, volume terms, and in-VPC deployment billed through your existing AWS account.
- Private offers & volume pricing
- In-your-VPC deployment (AWS Marketplace)Coming soon
- Procurement through your existing AWS bill
| Standard | Complex | Unlimited | Enterprise | |
|---|---|---|---|---|
| Sensors covered | Up to 2 — lidar-camera pair, or 2 lidars | Multi-lidar / multi-camera rigs | Any supported rig | Any supported rig |
| Recording size | Up to 10 GB | Larger recordings | No per-job limit | Custom |
| Billing | 1 credit per job | 1 credit per job | Flat monthly, no per-job billing | Private offer |
| Where it runs | Hosted API | Hosted API | Hosted API | Your AWS VPCComing soon |
| Support | Standard | Standard | Priority + direct line | Dedicated |
A calibration credit is consumed on a successful job and tied to the API key you check out with; a failed job refunds the credit automatically. Exact sensor-count and size thresholds for standard vs. complex are confirmed at checkout.
Payments via Stripe. Checkout is handled by Stripe — Deepen never sees or stores your card details.
Per-customer API keys. API access is scoped to a key issued to your account, not shared credentials.
Data handling by path. Hosted API: your recording is uploaded to Deepen for processing. AWS Marketplace (in-VPC): your data never leaves your AWS account.
Tell us about your rig
Sensors, rig type, recording format, and which path you want. We reply with access details.