API reference

Assets in the selected page. Empty when the request named a grouping.

Set only when the request named a grouping. An asset the grouping cannot place is absent - uploads and imports have no producing task - so list without a grouping to reach those.

Opaque token for the next page; empty on the final page.

Optional client-supplied resource id.

Asset metadata and ingestion source.

Asset id, ``asset_<hex>``.

User-visible label.

Media MIME type, e.g. ``image/png``.

Lifecycle state. Only ``READY`` assets can be read or used by a task.

Pixel width when known.

Pixel height when known.

Size in bytes serialized as a string for large-integer compatibility with JSON consumers.

Checksum when available.

Server-assigned.

Asset type, e.g. ``image``. Null for an untyped upload.

The asset's media files. Empty until the upload completes; an untyped asset then holds one part covering the whole media.

What a reader needs besides the bytes.

How the asset came to exist, when that was recorded.

True when the bytes are not retained: an upload made while the account does not retain content, or an output of an operation that purges. Both are deleted an hour after the last operation that names them finishes; an upload no operation consumes is deleted by age instead. ``contentPath`` is null for such an asset; read it through ``:createReadUrl``.

Already percent-encoded path for the asset. Append it unchanged to ``baseUrl`` before ``?`` and ``signedQuery``. This path does not grant access by itself. Null until the asset is ``READY`` or when unavailable; use ``assets/{asset}:createReadUrl`` as a fallback.

Unsigned content URL for the asset, ``baseUrl + contentPath``. It does not grant access by itself: the web app's read-prefix cookie authorizes it, and an API client appends ``?`` and a read prefix's ``signedQuery`` or uses ``assets/{asset}:createReadUrl`` instead. Null whenever ``contentPath`` is.

One grant per declared part; empty for URL or inline ingestion.

Project content prefix, ending in ``/``. Append an asset's already encoded ``contentPath`` unchanged.

Opaque, already encoded query string without the leading ``?``. Append it unchanged after ``baseUrl + contentPath``; do not parse or edit it.

When this read credential expires; create a new one after.

Asset id, ``asset_<hex>``.

User-visible label.

Media MIME type, e.g. ``image/png``.

Lifecycle state. Only ``READY`` assets can be read or used by a task.

Pixel width when known.

Pixel height when known.

Size in bytes serialized as a string for large-integer compatibility with JSON consumers.

Checksum when available.

Server-assigned.

Asset type, e.g. ``image``. Null for an untyped upload.

The asset's media files. Empty until the upload completes; an untyped asset then holds one part covering the whole media.

What a reader needs besides the bytes.

How the asset came to exist, when that was recorded.

True when the bytes are not retained: an upload made while the account does not retain content, or an output of an operation that purges. Both are deleted an hour after the last operation that names them finishes; an upload no operation consumes is deleted by age instead. ``contentPath`` is null for such an asset; read it through ``:createReadUrl``.

Already percent-encoded path for the asset. Append it unchanged to ``baseUrl`` before ``?`` and ``signedQuery``. This path does not grant access by itself. Null until the asset is ``READY`` or when unavailable; use ``assets/{asset}:createReadUrl`` as a fallback.

Unsigned content URL for the asset, ``baseUrl + contentPath``. It does not grant access by itself: the web app's read-prefix cookie authorizes it, and an API client appends ``?`` and a read prefix's ``signedQuery`` or uses ``assets/{asset}:createReadUrl`` instead. Null whenever ``contentPath`` is.

Asset id, ``asset_<hex>``.

User-visible label.

Media MIME type, e.g. ``image/png``.

Lifecycle state. Only ``READY`` assets can be read or used by a task.

Pixel width when known.

Pixel height when known.

Size in bytes serialized as a string for large-integer compatibility with JSON consumers.

Checksum when available.

Server-assigned.

Asset type, e.g. ``image``. Null for an untyped upload.

The asset's media files. Empty until the upload completes; an untyped asset then holds one part covering the whole media.

What a reader needs besides the bytes.

How the asset came to exist, when that was recorded.

True when the bytes are not retained: an upload made while the account does not retain content, or an output of an operation that purges. Both are deleted an hour after the last operation that names them finishes; an upload no operation consumes is deleted by age instead. ``contentPath`` is null for such an asset; read it through ``:createReadUrl``.

Already percent-encoded path for the asset. Append it unchanged to ``baseUrl`` before ``?`` and ``signedQuery``. This path does not grant access by itself. Null until the asset is ``READY`` or when unavailable; use ``assets/{asset}:createReadUrl`` as a fallback.

Unsigned content URL for the asset, ``baseUrl + contentPath``. It does not grant access by itself: the web app's read-prefix cookie authorizes it, and an API client appends ``?`` and a read prefix's ``signedQuery`` or uses ``assets/{asset}:createReadUrl`` instead. Null whenever ``contentPath`` is.

Short-lived download URL for the asset's bytes. Anyone with the URL can read the asset until it expires; create a fresh one rather than persisting this.

When ``readUrl`` stops authorizing the download.

Expected upload size in bytes, serialized on the wire as a string. Capped at 1 GiB.

Short-lived upload URL. Send the bytes here without the World Labs API key.

HTTP verb to use for the upload, e.g. PUT.

When this upload grant expires; create a new one after.

Headers the client MUST include on the upload request.

Parts that need new upload grants. Empty selects every declared part.

One new upload grant per requested part role.

Operations ordered from newest to oldest.

Token for the next page; absent when there are no more.

Short operation id used in ``/operations/{operation}`` paths.

Account that owns the operation.

Task information and optional progress details. Use ``metadata.task`` to interpret a generic operation response, and use ``done`` to determine completion.

Whether the operation is terminal. When true, a non-null ``error`` indicates failure; otherwise the operation succeeded.

Failure details when ``done`` is true and the task failed; null while running and after success.

Task execution deadline as Unix seconds, when one is exposed. This is not an asset URL expiration.

Unix seconds when the operation was accepted.

Task-specific result when ``done`` is true and the task succeeded; null while running and after failure.

Full resource name for the operation. For project operations: ``accounts/{account}/projects/{project}/operations/{operation}``. Operation paths accept the short ``id``.

Optional caller-provided reason for cancellation.

Cancellation idempotency key, at most 36 characters; supply to make retries idempotent. Server generates one if omitted.

Short operation id used in ``/operations/{operation}`` paths.

Account that owns the operation.

Task information and optional progress details. Use ``metadata.task`` to interpret a generic operation response, and use ``done`` to determine completion.

Whether the operation is terminal. When true, a non-null ``error`` indicates failure; otherwise the operation succeeded.

Failure details when ``done`` is true and the task failed; null while running and after success.

Task execution deadline as Unix seconds, when one is exposed. This is not an asset URL expiration.

Unix seconds when the operation was accepted.

Task-specific result when ``done`` is true and the task succeeded; null while running and after failure.

Full resource name for the operation. For project operations: ``accounts/{account}/projects/{project}/operations/{operation}``. Operation paths accept the short ``id``.

The request as the caller sent it, projected through the task's current public schema when that schema still accepts it and as recorded otherwise. Null only for early operations that retained no caller-shaped request.

The Operation's ``response``, served the same way.

The Operation's ``error``, served the same way.

Seconds to block waiting for the operation to finish, capped server-side at 30; omit to use the cap. Best-effort: the operation may still be running when this returns.

Short operation id used in ``/operations/{operation}`` paths.

Account that owns the operation.

Task information and optional progress details. Use ``metadata.task`` to interpret a generic operation response, and use ``done`` to determine completion.

Whether the operation is terminal. When true, a non-null ``error`` indicates failure; otherwise the operation succeeded.

Failure details when ``done`` is true and the task failed; null while running and after success.

Task execution deadline as Unix seconds, when one is exposed. This is not an asset URL expiration.

Unix seconds when the operation was accepted.

Task-specific result when ``done`` is true and the task succeeded; null while running and after failure.

Full resource name for the operation. For project operations: ``accounts/{account}/projects/{project}/operations/{operation}``. Operation paths accept the short ``id``.

`accounts/{account}/projects/{project}/operations/{operation}/webhookDelivery`.

The value sent in the `webhook-id` header; absent while SCHEDULED or PUBLISH_FAILED.

The accepted webhookUrl; absent once the operation's content was purged, while the delivery record itself stays.

SCHEDULED until the operation is terminal and handed over; PUBLISH_FAILED when Marble could not hand the completion to its webhook service (poll the operation instead); then the delivery's own state: PENDING (waiting for the next attempt), IN_FLIGHT, DELIVERED, SUPPRESSED (the receiver answered 410), EXHAUSTED (the 24-hour window closed, or after one attempt when the webhookUrl host resolves to a private address). A cancelled operation sends no event and answers 404.

The exact event body sent, once the delivery exists.

Sends attempted so far; a claim counts before its outcome.

Scheduled time of the next attempt while PENDING.

End of the 24-hour window.

Set when terminal.

Expires 90 days after the webhook service accepted the delivery.

Where Marble POSTs one signed task.succeeded or task.failed event when this operation finishes; retried for 24 hours. Verify the signature with the public keys at /.well-known/webhooks/jwks.json. Cannot be combined with ?wait=true. https on port 443 only, no IP literals. Developer API only.

Purge this operation's outputs and the transient uploads it consumed one hour after it finishes. Omitted, the account's setting applies; true raises it for this operation; false is refused when the account already purges. Uploads in the library are never purged by an operation.

Posed depth frames, one per target camera and posed at it, in target order; each camera is 1280x720. Depth only: frames carry no imageAsset, maskAsset, or depth confidenceAsset. Leave empty to generate from the prompt alone.

Posed RGB photographs of the scene, each an image and its camera in the targets' coordinate convention and scale. The generated views stay consistent with them: the servable feeds them to the model as views it has already committed, so a target that sees the same surfaces keeps their materials, colors, and lighting. Any cameras and any resolution; each is cover-resized and center-cropped onto 1280x720. Frames carry no maskAsset or depth. Together with contextFrames and targetCameras they fill at most 64 views of the servable's rollout.

Pinhole cameras at 1280x720 for the views to generate, in output order, returned in `frames`. At most 32.

Text prompt describing the scene.

Rewrite the prompt into the structured scene caption the model trained on before inference. Set false to send the prompt as is.

Voxel side length in the normalized scene gauge (90th-percentile disparity is approximately 1). The recommended range is 0 to 0.4. Omit or set to 0 to keep the original depth conditioning.

Frame the voxelization grid axes align to. 'world' (the default) axis-aligns voxels with the request's world coordinates, so world-axis-aligned faces (blockout walls) quantize flat; 'gauge' keeps the legacy grid aligned to the normalized scene gauge (the recentered mean camera pose). Ignored unless voxelSize is set.

Model-specific parameters for atlasChisel.

Return the generated frames as posed RGBD: they are reconstructed together so the depth lands in the request's own camera frame and scale, and every entry in `frames` then carries a `depth` buffer. The contextFrames' own depth is not reconstructed or returned. A source photograph joins the reconstruction as an anchor, and gets no depth back, only when its image is at the generated resolution and its camera's principal point is centered. Needs at least two target cameras. Limitation: the depth scale is recovered from the camera centers that joined, so targets that share one center (a pure-rotation rig) and no anchor come back with a 0.0 or NaN scale and a success status.

Short operation id used in ``/operations/{operation}`` paths.

Account that owns the operation.

Task information and optional progress details. Use ``metadata.task`` to interpret a generic operation response, and use ``done`` to determine completion.

Whether the operation is terminal. When true, a non-null ``error`` indicates failure; otherwise the operation succeeded.

Failure details when ``done`` is true and the task failed; null while running and after success.

Task execution deadline as Unix seconds, when one is exposed. This is not an asset URL expiration.

Unix seconds when the operation was accepted.

``AtlasChiselResponse`` result when ``done`` is true and the task succeeded; null while running and after failure.

Full resource name for the operation. For project operations: ``accounts/{account}/projects/{project}/operations/{operation}``. Operation paths accept the short ``id``.

Generated RGB frames (image + camera), one per target camera in order.

Final prompt supplied to inference.

Meridian request id from servable runtime metadata.

Where Marble POSTs one signed task.succeeded or task.failed event when this operation finishes; retried for 24 hours. Verify the signature with the public keys at /.well-known/webhooks/jwks.json. Cannot be combined with ?wait=true. https on port 443 only, no IP literals. Developer API only.

Purge this operation's outputs and the transient uploads it consumed one hour after it finishes. Omitted, the account's setting applies; true raises it for this operation; false is refused when the account already purges. Uploads in the library are never purged by an operation.

Posed RGBD context views: each an image, its depth buffer, and its camera, all required. On the reference-context warp route the depth conditions the generation geometrically, so the generated views stay consistent with the provided scene; the hero base checkpoint conditions on the posed images only and does not consume the depth.

Pinhole cameras for the views to generate, in output order. Generated frames are returned in `frames`, one per camera.

Text prompt describing the scene, if any.

Enhance the prompt with the ViewGen preset before inference. With no prompt, the enhancer captions the context images.

Return the generated frames as posed RGBD: they are reconstructed together with the context frames so the depth lands in the request's own camera frame and scale, and every entry in `frames` then carries a `depth` buffer. A context frame joins that reconstruction only when its image is at the generated resolution and its camera's principal point is centered. The scale is recovered from the camera centres that joined, so a request whose joined cameras all share one centre (a pure-rotation rig) is rejected.

Model-specific parameters for atlasGenerate.

Short operation id used in ``/operations/{operation}`` paths.

Account that owns the operation.

Task information and optional progress details. Use ``metadata.task`` to interpret a generic operation response, and use ``done`` to determine completion.

Whether the operation is terminal. When true, a non-null ``error`` indicates failure; otherwise the operation succeeded.

Failure details when ``done`` is true and the task failed; null while running and after success.

Task execution deadline as Unix seconds, when one is exposed. This is not an asset URL expiration.

Unix seconds when the operation was accepted.

``AtlasGenerateResponse`` result when ``done`` is true and the task succeeded; null while running and after failure.

Full resource name for the operation. For project operations: ``accounts/{account}/projects/{project}/operations/{operation}``. Operation paths accept the short ``id``.

Generated RGB frames (image + camera), one per target camera in order. Every frame also carries a `depth` buffer when the request set returnDepth.

Final prompt supplied to inference, if any.

Meridian request id from servable runtime metadata.

Where Marble POSTs one signed task.succeeded or task.failed event when this operation finishes; retried for 24 hours. Verify the signature with the public keys at /.well-known/webhooks/jwks.json. Cannot be combined with ?wait=true. https on port 443 only, no IP literals. Developer API only.

Purge this operation's outputs and the transient uploads it consumed one hour after it finishes. Omitted, the account's setting applies; true raises it for this operation; false is refused when the account already purges. Uploads in the library are never purged by an operation.

The views to complete, in output order: each an image, its alpha mask, and its camera. The mask is an 8-bit grayscale PNG on the image grid where 1 is kept -- those pixels are the observed image -- and 0 is what the model fills in. Each view is completed at its targetCameras entry of the same index.

Pinhole cameras for the views to generate, one per context frame in the same order. Warning: the partial checkpoints condition target i on contextFrames[i]'s masked view and were trained with one context view per target, rendered from the target's own viewpoint. A count that differs from contextFrames, or a target off its frame's camera, is accepted but runs outside the training distribution and may generate degraded views.

The edit to make. With enhancePrompt on (the default), write an instruction that names what to add, remove, replace, or restyle and where, such as 'replace the yellow car with a stone fountain in the middle of the courtyard'. The enhancer reads it with the original context images but not the masks. Without a prompt it describes the images as they are, which tends to restore masked objects, so state removals explicitly. With enhancePrompt false the model receives the text unchanged as a caption of the finished image, so describe the whole finished scene instead.

Rewrite the prompt before inference: the edit instruction and the context images become a detailed description of the finished scene, returned as promptUsed. Set false to send the prompt exactly as given.

Return the completed frames as posed RGBD: they are reconstructed together so the depth lands in the request's own camera frame and scale, and every entry in `frames` then carries a `depth` buffer. Needs at least two targetCameras. Limitation: the depth scale is recovered from the frames' camera centres, so views that share one centre (a pure-rotation rig) come back with a 0.0 or NaN scale and a success status.

Model-specific parameters for atlasMasked.

Short operation id used in ``/operations/{operation}`` paths.

Account that owns the operation.

Task information and optional progress details. Use ``metadata.task`` to interpret a generic operation response, and use ``done`` to determine completion.

Whether the operation is terminal. When true, a non-null ``error`` indicates failure; otherwise the operation succeeded.

Failure details when ``done`` is true and the task failed; null while running and after success.

Task execution deadline as Unix seconds, when one is exposed. This is not an asset URL expiration.

Unix seconds when the operation was accepted.

``AtlasMaskedResponse`` result when ``done`` is true and the task succeeded; null while running and after failure.

Full resource name for the operation. For project operations: ``accounts/{account}/projects/{project}/operations/{operation}``. Operation paths accept the short ``id``.

Generated frames (image + camera): one per target camera, in order. Every frame also carries a `depth` buffer when the request set returnDepth.

Final prompt supplied to inference, if any.

Meridian request id from servable runtime metadata.

Where Marble POSTs one signed task.succeeded or task.failed event when this operation finishes; retried for 24 hours. Verify the signature with the public keys at /.well-known/webhooks/jwks.json. Cannot be combined with ?wait=true. https on port 443 only, no IP literals. Developer API only.

Purge this operation's outputs and the transient uploads it consumed one hour after it finishes. Omitted, the account's setting applies; true raises it for this operation; false is refused when the account already purges. Uploads in the library are never purged by an operation.

Text prompt to generate from.

Output width-to-height ratio. Omit for the model default.

Whether to enhance the prompt before generation. Defaults to true.

Optional RNG seed.

Diffusion step count.

Number of images to generate.

Also estimate depth per image (metric, single-view): every frame in `frames` then carries a `depth` buffer and the camera it was estimated under.

Short operation id used in ``/operations/{operation}`` paths.

Account that owns the operation.

Task information and optional progress details. Use ``metadata.task`` to interpret a generic operation response, and use ``done`` to determine completion.

Whether the operation is terminal. When true, a non-null ``error`` indicates failure; otherwise the operation succeeded.

Failure details when ``done`` is true and the task failed; null while running and after success.

Task execution deadline as Unix seconds, when one is exposed. This is not an asset URL expiration.

Unix seconds when the operation was accepted.

``AtlasTextToImageResponse`` result when ``done`` is true and the task succeeded; null while running and after failure.

Full resource name for the operation. For project operations: ``accounts/{account}/projects/{project}/operations/{operation}``. Operation paths accept the short ``id``.

Generated images, one frame per sample in generation order. Every frame also carries its estimated camera and a `depth` buffer when the request set returnDepth.

Final prompt supplied to inference, if any.

Resolved width-to-height ratio used for generation.

Where Marble POSTs one signed task.succeeded or task.failed event when this operation finishes; retried for 24 hours. Verify the signature with the public keys at /.well-known/webhooks/jwks.json. Cannot be combined with ?wait=true. https on port 443 only, no IP literals. Developer API only.

Purge this operation's outputs and the transient uploads it consumed one hour after it finishes. Omitted, the account's setting applies; true raises it for this operation; false is refused when the account already purges. Uploads in the library are never purged by an operation.

When the task is answered at submission, return each output file as base64 in that response rather than by assetId and url. This skips storing the files before the answer and the caller's download after it. A task that is not answered at submission, and every later read of the operation, names the outputs by assetId and url either way.

Ordered image inputs (min 1). A frame that carries a camera, a depth buffer or a mask is rejected rather than quietly ignored: none of them reaches the reconstruction.

Place the first camera at the origin facing forward.

Return the depth, confidence and camera intrinsics on this (width, height) pixel grid. The reconstruction is scaled to cover the requested size and center-cropped to it, so the result is exactly the size asked for and never stretched, and the intrinsics are updated with it -- unprojecting the returned depth with the returned camera gives the same geometry either way. A requested aspect that differs from the reconstruction's costs field of view, since the crop is what makes the size exact, and centroidWorld then describes the cropped view. Omit for the 1280 by 720 default; pass null to take the instance's own default.

Bundle-adjust the estimated cameras against dense matches before answering. The backbone's poses are good to about half a degree, which is enough to reconstruct from and not enough to refine against: the residual shows up as blur wherever two views disagree. The solve anchors on the depth this task has just produced, so it costs a matcher pass and a solve rather than another reconstruction, and it needs two or more frames. A solve that moves the cameras further than the guards allow is thrown away and the unrefined reconstruction is returned, which is a success rather than an error.

Short operation id used in ``/operations/{operation}`` paths.

Account that owns the operation.

Task information and optional progress details. Use ``metadata.task`` to interpret a generic operation response, and use ``done`` to determine completion.

Whether the operation is terminal. When true, a non-null ``error`` indicates failure; otherwise the operation succeeded.

Failure details when ``done`` is true and the task failed; null while running and after success.

Task execution deadline as Unix seconds, when one is exposed. This is not an asset URL expiration.

Unix seconds when the operation was accepted.

``Images2PosedRGBDResponse`` result when ``done`` is true and the task succeeded; null while running and after failure.

Full resource name for the operation. For project operations: ``accounts/{account}/projects/{project}/operations/{operation}``. Operation paths accept the short ``id``.

One reconstructed frame per input image, in request order.

When refinePoses was requested, whether the refined cameras were kept. False means the original reconstruction was returned; null means refinement was not requested.

Where Marble POSTs one signed task.succeeded or task.failed event when this operation finishes; retried for 24 hours. Verify the signature with the public keys at /.well-known/webhooks/jwks.json. Cannot be combined with ?wait=true. https on port 443 only, no IP literals. Developer API only.

Purge this operation's outputs and the transient uploads it consumed one hour after it finishes. Omitted, the account's setting applies; true raises it for this operation; false is refused when the account already purges. Uploads in the library are never purged by an operation.

Cameras the splats are rendered from. The surface is reconstructed from those renders, so geometry no camera sees is not meshed. Name a strategy -- `auto_anchors` (the default) finds viewpoints in the scene's free space, `manual_anchors` takes them from the request, `exterior_sphere` rings the scene from outside for an object or turntable capture -- or pass a list of cameras to render as given, at most 512, sharing one width and height between 64 and 1024 that becomes the render resolution.

Finer control over how the splats are rendered and how the surface is extracted. Omit for the defaults.

Region to extract, as an oriented box in Three.js coordinates. Omit to mesh the whole scene.

Decimate the extracted mesh to at most this many faces. A target above the extracted count does nothing. Omit to keep every face.

Mesh appearance: 'image_texture' projects rendered views onto a UV atlas, 'vertex_color' bakes per-vertex colors, and 'none' leaves the mesh untextured.

Accepted: image_texture, vertex_color, none

Height and width of the texture atlas, in pixels, for `image_texture` mode. One rendered view plus its border has to fit, so this must be at least 2% above the render size in play: the larger render bank under the anchor strategies, `renderHw` under `exterior_sphere`, or the supplied cameras' own size.

The Gaussian splat scene (.spz) to mesh. Inline base64 must carry a `data:` prefix to declare its media type: asset creation otherwise infers the type from the bytes, and the sniffer knows image formats only.

Short operation id used in ``/operations/{operation}`` paths.

Account that owns the operation.

Task information and optional progress details. Use ``metadata.task`` to interpret a generic operation response, and use ``done`` to determine completion.

Whether the operation is terminal. When true, a non-null ``error`` indicates failure; otherwise the operation succeeded.

Failure details when ``done`` is true and the task failed; null while running and after success.

Task execution deadline as Unix seconds, when one is exposed. This is not an asset URL expiration.

Unix seconds when the operation was accepted.

``Splats2MeshResponse`` result when ``done`` is true and the task succeeded; null while running and after failure.

Full resource name for the operation. For project operations: ``accounts/{account}/projects/{project}/operations/{operation}``. Operation paths accept the short ``id``.

The generated GLB mesh.

Anchor positions the cameras were generated from, in Three.js coordinates. Null when no anchors were used: cameras were supplied directly, or `exterior_sphere` was chosen.

Deprecated runtime diagnostics. Informational only -- keys are not part of the contract and may change.