AIMoCap
AIMoCap

MOCAP API

Video mocap API for async motion jobs

Use the AIMoCap video mocap API to create async jobs, upload source video, poll status, and download FBX or robot motion outputs.

For developers looking for an API-driven video mocap pipeline.

Short answer

AIMoCap's mocap API is an async job lifecycle for uploaded clips, target IDs, v-credit accounting, polling, and artifact downloads across Default or Unitree G1 outputs.

When to use AIMoCap

Use the mocap API when motion processing must fit into a product workflow with upload URLs, target selection, status polling, result downloads, and API v-credit accounting.

When not to use AIMoCap

Do not use the API when you need synchronous frame-by-frame processing or a private custom target that has not been prepared for your account.

The AIMoCap API is designed for production integrations that need asynchronous video mocap jobs instead of manual browser-only workflows.

Developers can create a job, upload video to the returned upload URL, complete the upload, poll job status, and download available outputs.

This makes the API page different from a generic product page: it should help an engineer understand job state, supported targets, billing units, and failure boundaries before writing client code.

Current public API support

  • For the general mocap API, the current public target set is Default for animation output and Unitree G1 for robot-oriented output.
  • FBX export FPS supports 24, 30, 60, and 120.
  • For mocap API jobs, API v-credit is tracked separately from browser Studio credits.
  • API v-credit is based on validated processing duration, not on a client-declared file size or a create request alone.
  • System-side processing failures should be refunded through the API ledger, while user-side validation failures do not start billable processing.
  • Trim fields are optional; if no trim end is provided, AIMoCap resolves the processing window from the uploaded source video.
  • Robot motion API outputs are reviewable target data for downstream simulation or controller validation, not direct robot hardware-control commands.
  • The API is asynchronous by design, so clients should persist the job ID and poll status rather than wait on a single long request.
  • API clients should persist the job ID immediately after create because upload, complete-upload, polling, and download are separate steps.
  • Clients should handle per-target outputs rather than assuming every completed job returns the same artifact type.

Mocap API decision matrix

The API is a fit when your product can manage an asynchronous job lifecycle instead of waiting for a single blocking conversion request.

A product needs upload URLs, polling, and repeatable result downloads
Use the public mocap API, persist the job ID immediately, and track per-target artifacts separately.
Client code should handle create, upload, complete-upload, status polling, result download, and possible per-target output differences.
You need a batch pipeline for Default and Unitree G1 outputs
Request supported target IDs explicitly and keep API v-credit accounting separate from browser Studio credits.
Do not assume every target returns the same file type; FBX and robot-oriented data need different downstream validation.
You need real-time frame streaming or private target support before setup
Do not model the API as synchronous real-time processing; prepare private targets or integration needs separately first.
The current public API is async and target-scoped; long-running jobs, upload validation, and billing happen across multiple steps.

What developers usually check before integrating

Developer discussions about video-processing APIs usually focus on job lifecycle, upload reliability, billing predictability, retry behavior, and whether examples match the documented API.

Async behavior needs to be explicit

API users expect long video jobs to be non-blocking, so create/upload/complete/poll/download should stay visible across docs, examples, and landing pages.

Billing units must be predictable

A recurring developer concern is whether usage cost can be estimated and audited. AIMoCap should keep v-credit separate from web credits and explain when the API ledger changes.

Failure states matter as much as happy paths

Integrators need to know what happens for invalid FPS, trim ranges, large files, insufficient v-credit, and processing failures before they build a product workflow.

API integration facts

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

Async lifecycle

The public API is designed around create, upload, complete-upload, poll status, and download, so long-running mocap jobs do not block client requests.

Multi-target jobs

A single API job can request supported targets such as Default and Unitree G1 when the account and job limits allow it; robot-target output should still pass downstream simulation, controller, or safety validation before hardware use.

Separate accounting

API jobs use API v-credit, while browser Studio jobs use web credits; this keeps product integrations and manual use easier to audit.

Result retrieval

Client code should be prepared to download different result artifacts depending on requested targets, such as FBX for Default output or robot-oriented data for Unitree G1.

Client state boundary

A robust client stores job ID, requested target IDs, upload completion state, polling status, and downloaded artifact keys separately instead of treating the API as a single blocking conversion call.

API integration flow

01

Create a job

Send job metadata such as title, supported target IDs, optional trim fields, and export FPS.

02

Upload and complete

Upload the source video to the provided upload URL, then call complete-upload so AIMoCap can queue processing.

03

Poll and download

Poll the job status and download available FBX, preview video, or Unitree G1 robot motion output when complete.

04

Separate API accounting

Track API v-credit separately from browser Studio credits so product usage, automated jobs, and manual Studio jobs can be audited independently.

Common questions

Can one API job request both Default and Unitree G1 outputs?

Yes. The API supports multiple target IDs in one job when the account and job limits allow it. Unitree G1 output is robot-oriented motion data, not a direct hardware-command stream.

When are API v-credits used?

API jobs use API v-credit after the uploaded source is validated for processing. Cost is based on the resolved processing duration, rounded for billing, and stays separate from web Studio credits. If AIMoCap has a system-side processing failure after charging, the API ledger should record the refund path instead of mixing it with Studio credit usage.

Where are API fields documented?

The API reference documents supported targets, trim fields, export FPS, upload, polling, and result download behavior.

Is the API synchronous?

No. AIMoCap API jobs are asynchronous: create the job, upload the video, complete the upload, poll status, and download results when processing finishes.

Do API jobs use the same credits as Studio?

No. API jobs use API v-credit, while browser Studio mocap jobs use web credits. This separation keeps automated product usage easier to track.

What should an API client persist?

Persist the job ID, requested target IDs, upload completion state, current polling status, and the result artifact URLs or downloaded files for each completed target.

Sources reviewed

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