Is there an Atlas API? Status, and how to call World Labs today (independent guide)

There is no public Atlas API. There is a public World Labs API, and it is the one you should learn now, because Atlas builds on the same model family and platform. This page explains what you can call today, what it costs, and what is likely to change. It is an independent guide, not affiliated with World Labs; the official reference is docs.worldlabs.ai/api.

Status at a glance

The World API launched on January 21, 2026 and accepts text, single images, multiple images, 360° panoramas and video as inputs, returning a navigable 3D world that can be rendered in the browser or exported (World Labs).

Authentication and credits

You get an API key from the World Labs developer platform, then send it in a WLT-Api-Key header — not as a bearer token. Usage is billed in credits: $1 buys 1,250 credits and the minimum purchase is $5 for 6,250 credits. API credits are separate from the Marble web app’s credits, do not expire, and can auto-refill (World Labs docs). Check your balance with the credits endpoint:

curl https://api.worldlabs.ai/marble/v1/credits \
  -H "WLT-Api-Key: $WORLDLABS_API_KEY"

That returns a remaining_credits number. Sending the key as Authorization: Bearer instead returns 401 with {"message": "No API key found in request"}.

Generate a world

A single request starts generation. The prompt goes in a world_prompt object whose type selects the input mode — there is no top-level prompt field. The examples below were run against the live API on September 13, 2026.

curl -X POST https://api.worldlabs.ai/marble/v1/worlds:generate \
-H "WLT-Api-Key: $WORLDLABS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "model": "marble-1.0-draft",
  "display_name": "greenhouse",
  "world_prompt": {
    "type": "text",
    "text_prompt": "a sunlit greenhouse full of ferns, glass roof, wooden benches"
  }
}'

import os, requests

API = "https://api.worldlabs.ai"
headers = {"WLT-Api-Key": os.environ["WORLDLABS_API_KEY"]}

r = requests.post(
f"{API}/marble/v1/worlds:generate",
headers=headers,
json={
"model": "marble-1.0-draft",
"world_prompt": {"type": "text", "text_prompt": "a sunlit greenhouse full of ferns"},
},
timeout=30,
)
r.raise_for_status()
operation = r.json()
print(operation["operation_id"]) # poll this id until the world is ready

const API = 'https://api.worldlabs.ai';

const res = await fetch(API + '/marble/v1/worlds:generate', {
method: 'POST',
headers: {
'WLT-Api-Key': process.env.WORLDLABS_API_KEY,
'Content-Type': 'application/json',
},
body: JSON.stringify({
model: 'marble-1.0-draft',
world_prompt: { type: 'text', text_prompt: 'a sunlit greenhouse full of ferns' },
}),
signal: AbortSignal.timeout(30_000),
});
if (!res.ok) throw new Error('generate failed: ' + res.status);
const operation = await res.json(); // poll operation.operation_id until done

For image input, swap the world_prompt type: image takes an image_prompt and an is_pano flag (a tri-state string, auto by default), multi-image takes a multi_image_prompt array and caps at four images unless you also send reconstruct_images: true, and video takes a video_prompt capped at 100 MB (reference).

Polling and exports

World generation takes minutes, not seconds, so the generate call returns an operation rather than a finished world. The pattern is:

1. Call generate and store operation_id from the response. There is no operation_url field to follow.
2. Poll GET /marble/v1/operations/{operation_id} on an increasing interval, starting around three seconds and backing off to fifteen.
3. When done turns true, read response.world_id and take the asset URLs from response.assets.

Two things worth knowing before you build the progress UI. metadata.progress.status is a state enum — IN_PROGRESS, then SUCCEEDED — with no percentage anywhere in the payload, so a numeric progress bar has to be estimated from elapsed time rather than reported. And cost stays null until the operation succeeds, then itemises what you were actually charged; a draft world from a text prompt comes back as 80 credits for Pano generation (text) plus 150 for Draft world generation.

A finished world already carries SPZ splats at three resolutions (full_res, 500k, 100k) and a free low-poly collider mesh in response.assets, served from a CDN that needs no auth header. PLY splat export is free through the export endpoint; the high-quality GLB mesh is the one paid export at 3,500 credits (World Labs docs). Splats open directly in the free splat viewer and import into engines as described in the game development guide. A complete, runnable walk-through is in the Marble World API quickstart in TypeScript.

Do not wait synchronously inside a web request for an operation to finish. Queue the job, poll from a worker, and show the user its status. That is how the generator on this site works.

Rate limits and costs

World Labs publishes a default ceiling of roughly 3 world generation starts per minute and 60 per hour, counted per account rather than per API key; approved accounts can reach about 30 per minute, or 90 for draft generations (World Labs docs). Only starts are capped, not how many generations run concurrently. A 429 means the request was not accepted, so retry with exponential backoff and jitter and then poll the new operation — do not assume a duplicate is already running, and do not replay a paused queue all at once. Costs, as of September 13, 2026:

A request bills as the sum of its usage events, so a panorama generation event is added unless the input is already a 360° panorama. Sources: World Labs docs, rate limits, Radiance Fields. Worked examples and this site’s own plans are on the pricing page.

Error handling and retries

Two kinds of failure matter in practice.

Transient upstream errors (5xx, timeouts, 429) should be retried with exponential backoff: wait roughly 300 ms, then 600, then 1,200, and give up after three attempts. Always set a request timeout; a hung connection is worse than a failed one. Both examples above use a 30-second timeout on the generate call, which is generous for a request that only enqueues work.

Failed operations are different. If the operation you poll reports an error, retrying the same input usually produces the same error. Log the operation identifier, surface the message to the user, and refund any credits you reserved on your side. World Labs’ own billing charges per successful usage event (World Labs docs), so check the credits endpoint rather than assuming a failed job cost you 1,500 credits.

Keep keys server-side

The API key controls a prepaid balance. Never ship it to a browser or a mobile app. Call the World API from your server or an edge function, keep the key in a secrets manager, and expose your own narrower endpoint to clients. This site’s generator follows the same rule: the browser talks to atlasworldmodel.com, and only the server holds the World Labs key.

If you must let users bring their own key, store it encrypted, scope it to their account, and let them revoke it from the World Labs platform.

The Atlas API: what we know and don’t

Known, as of September 3, 2026:

• Atlas is in early access for select partners through a request form; no public documentation, price or general-availability date exists (Implicator).
• Atlas “builds on the Marble model” and follows the January 2026 World API in World Labs’ product lineage (Dealroom).
• Its capabilities exceed the current API surface: camera-controlled video up to 1440p and one minute, reconstruction from one to 100+ images, and explicit point cloud and splat outputs (The Decoder).

Unknown:

• Whether Atlas appears as a new model identifier on the existing generate endpoint or as a separate API.
• How camera paths and video inputs are expressed in a request.
• Pricing, which will almost certainly differ for video output.
• Rate limits and latency.

We update this section within 48 hours of any change; the changelog records each update. For the background on the model itself see what the Atlas world model is.

How this site’s API layer would route to Atlas

The generator on this site is live on the Marble World API; the Atlas part of this section is still a design, because Atlas has no public API. The tools sit behind a provider abstraction. A request describes only the input, such as text, images, a panorama or video, plus quality and export options. A provider adapter turns that into a World Labs call and polls the operation. Today that adapter calls Marble; if Atlas exposes an API, a second adapter with the same interface would take over, chosen by configuration.

For you that means the request you send to this site’s generator would not change if the model behind it did. Cost estimates come from the same layer, which is why the tool pages show a credit estimate before you generate. If you would rather call World Labs directly, the Marble World API guide documents the full flow.

Want to know the day the Atlas API opens? Follow the changelog or its RSS feed, which record every material change.