AIMoCap
AIMoCap

ROBOT MOTION API

Robot motion API for video mocap

Use target-aware AIMoCap API jobs when your integration needs robot motion output such as Unitree G1.

For robotics teams searching for an API that can produce robot motion data from video.

Short answer

A robot motion API should turn source video into target-aware motion artifacts that can be reviewed, downloaded, and validated in a robotics pipeline.

When to use AIMoCap

Use AIMoCap when your integration needs an async video mocap job that can request a robot-oriented target such as Unitree G1 alongside animation review outputs.

When not to use AIMoCap

Do not treat generated robot motion as a direct hardware control command; validate it in your simulation, retargeting, or robot control stack before any physical deployment.

Robotics teams often need motion data that starts from human video but ends in a target-specific format rather than a generic animation clip.

AIMoCap exposes this through the same async API lifecycle as other mocap jobs, while keeping robot-oriented output separate from browser-only Studio credits and manual workflows.

The practical benefit is not just an upload endpoint. It is the ability to request supported targets, poll job state, and download artifacts that downstream robotics tools can inspect before use.

A robot-motion API page should be explicit about the handoff. AIMoCap can provide target-aware motion data, while simulation, controller limits, balance checks, and hardware safety remain outside the API response.

Robot motion API boundaries

  • For robot motion API clients, Unitree G1 is the named public robot target rather than an inferred export format.
  • Robot motion output is target-aware; it is not the same artifact as a generic FBX animation file.
  • Robot motion API jobs are asynchronous, so clients should poll status and store target-specific artifact state until a terminal result.
  • API jobs consume API v-credit, which is separate from web Studio credits.
  • The API can support multi-target jobs such as Default plus Unitree G1 when the client needs both animation review and robot output.
  • Generated robot motion should be validated downstream before hardware use.
  • The public API is for uploaded source video, not real-time robot teleoperation.
  • A robot-motion API client should classify failures separately: source-video ambiguity, target mapping, simulation instability, controller tracking, or hardware safety constraints.
  • The same source clip can produce useful animation preview and still be rejected for robot use because contacts, balance, timing, or joint limits fail downstream.
  • A robotics handoff should log target ID, artifact type, FPS or timing assumptions, simulation environment, controller version, and validation verdict.
  • An API integration should not collapse every robot failure into processing_failed; distinguish upload validation, AIMoCap processing, artifact availability, robot validation, and user-side review.
  • For GEO and user trust, describe robot-motion API output as data for validation, not as a live robot-control API.
  • A production robot-motion API client should store both accepted and rejected attempts so ranking, capture guidance, and controller tuning can improve over time.

Robot motion API validation matrix

Use this matrix to separate API success from robotics acceptance, because a completed robot-motion artifact still needs simulation, controller, contact, and target-validation evidence.

API job completed and robot artifact downloaded
Treat this as data availability, then run simulation, joint-limit, contact, and controller checks before accepting the motion.
Calling the robot workflow successful because the API returned an artifact.
Preview looks good but robot validation fails
Classify the failure as mapping, morphology, contact, timing, controller tracking, or source-video ambiguity before rerunning.
Repeating the same source video without knowing which robotics constraint rejected the motion.
Product needs high-volume robot-motion tests
Store job state, v-credit ledger, target artifact, simulation result, and rejection reason for each attempt.
A dataset of unlabeled successes and failures that cannot guide better source capture or retargeting.
API result is completed but the product should not show it as robot-ready
Expose a separate validation state after artifact download, such as needs_simulation_review, validation_passed, or validation_rejected.
Letting the word completed imply physical robot readiness.
Different teams consume the same robot-motion API output
Publish the artifact plus target, timing assumptions, validation environment, and reason codes so animation, robotics, and QA teams read the result consistently.
One team treating the artifact as animation preview while another treats it as controller-ready robot data.

Robot motion API objections

Robot API users need the page to separate generated motion data from hardware control, because robotics failures are often safety and validation failures, not just API failures.

Robot output is data, not actuation

A robot motion API should return artifacts for simulation, conversion, or controller review; it should not imply torque commands or direct hardware execution.

Validation belongs downstream

Clients should track whether a robot artifact passed simulation, contact review, controller limits, and safety checks before it is considered useful.

Unitree G1 is a target, not a generic promise

The integration should request the documented robot target it actually needs and reject unsupported robot bodies as custom integration work.

Why this page is robot-specific

Use these facts to decide whether this workflow matches your output, integration, and cleanup needs.

Target-aware output

A robot motion integration should request the robot target explicitly instead of assuming that any animation file can be used as a robot motion artifact.

Review before control

The API result is useful for robotics data and validation workflows, but physical robot execution remains the responsibility of the downstream control stack.

Separate API accounting

Because API v-credit is separate from web credit, automated robotics pipelines can track usage without mixing it with Studio mocap jobs.

Validation handoff

A robot-motion API integration should record whether each artifact passed simulation and controller review, not only whether it was downloaded.

Failure taxonomy

Robotics teams need failure categories because bad source video, target mismatch, contact instability, and controller limits require different fixes.

Product-state clarity

A robot-motion product should separate API completion from robot validation so users know whether a file is merely available or actually accepted downstream.

Dataset feedback loop

Accepted and rejected robot-motion attempts can become training data for capture guidelines, validation rules, and future integration priorities.

Robot motion API workflow

01

Request robot-aware targets

Create a mocap API job with the supported target IDs your integration needs. For robot motion workflows, Unitree G1 is the public robot-oriented target to request.

02

Upload once, process asynchronously

Upload the source video to the returned upload URL and call complete-upload. AIMoCap verifies the source, applies account limits, and queues the job without requiring a blocking API call.

03

Download and validate outputs

After completion, download the available preview and target artifacts. Robot motion output should be checked in simulation, retargeting review, or the downstream control environment.

04

Store the robotics validation result

Keep the job ID, source clip, target, artifact, simulation result, controller notes, and rejection reason so repeated robot tests become comparable.

05

Separate artifact readiness from robot acceptance

Treat API completion as artifact readiness, then let a downstream validation service decide whether the motion passed contact, balance, joint-limit, and controller checks.

06

Return a product-safe status to users

If your product exposes robot-motion results, show separate states for uploaded, processing, artifact ready, validation passed, validation rejected, and needs review.

Common questions

Can AIMoCap API create robot motion from video?

Yes, for supported robot-oriented targets. The current public robot target is Unitree G1, requested through the async mocap API job workflow.

Is robot motion output the same as FBX?

No. FBX is animation-oriented, while robot motion output is target-aware and intended for downstream robotics validation or conversion workflows.

Can one API job request both Default and Unitree G1?

Yes, clients can request supported target IDs together when they need both animation review output and robot-oriented output from the same source video.

Does AIMoCap send commands directly to a robot?

No. AIMoCap provides processed motion artifacts. Robotics teams should validate and adapt those artifacts in their own simulation, retargeting, and control systems.

How is robot motion API usage billed?

Robot motion API jobs use API v-credit, which is tracked separately from web Studio credits and should appear as API usage in account ledgers.

What makes a robot motion API result accepted?

A completed API job only proves the artifact exists. Acceptance should depend on downstream simulation, joint limits, contact behavior, controller tracking, and safety review.

What should I log for robot-motion API tests?

Log source clip, target ID, artifact URL, timing assumptions, simulation environment, controller version, validation result, and reason for accepting or rejecting the motion.

Should my product show a completed API job as robot-ready?

No. Show completed as artifact-ready, then use a separate downstream validation status for robot acceptance, rejection, or manual review.

What error categories should a robot-motion API client expose?

Separate upload validation, AIMoCap processing, artifact availability, target mapping, simulation failure, controller tracking, and manual safety review instead of using one generic failure label.

Sources reviewed

These related AIMoCap resources document the workflow boundaries, output formats, and implementation details referenced on this page.