The default archive policy has no automatic expiry
Archiving requires configured frame storage on the deployment. When storage is configured, the default policy enables archiving and keeps frames with no expiry time. An organisation with an explicit policy keeps its own setting. The service does not automatically delete persisted frame bytes. Its background loop reconciles unconfirmed writes and reports storage usage; it does not remove an archived image. Do not assume that returning a device, deleting a chat thread or closing an account erases a separately archived frame.Read one available frame
GET /v1/frames/{frameId} returns a short-lived signed URL for one archived
image. Obtain the frame id from a run’s lastFrame.frameId or an action
receipt’s observedFrame, then call the route with your bearer credential.
The credential needs devices:read or permission to run tasks, and any device
restriction on the credential applies to the frame too.
An unknown frame, another organisation’s frame, an unconfirmed write, an
expired frame or a frame outside the credential’s devices all return
404 frame_not_found. A deployment without frame storage returns that answer
for every frame id. A live screenshot can still be available even when no
archived copy exists.
The former run-frames and receipt-frame endpoints have been withdrawn. Use the
current single-frame route rather than those old paths.
The store is private, and a read uses a URL we mint
The store is private in its own right: an anonymous request, a request carrying the public API key, and a request from a signed in browser session are all refused, including the request that only asks whether an object exists. The route returns a signed URL for one image rather than pixels. Its normal lifetime is one minute, with a signer cap of five minutes; a finite frame expiry can shorten it. The response containsframeId and url, not a TTL
field. Treat the URL as a password for that one image while it lasts: do not
store it, log it, or paste it into a bug report. Fetch a new URL when you need
to view the image again.
Before any URL is signed, the frame is looked up in the database under your
organisation’s own row level policy, and the storage location is read out of
that row. It is never constructed from the values in a request. That
distinction is the authorisation: a location built from arguments would be a
valid looking location for somebody else’s frame, and object storage has no
idea which tenant asked.
What we do not do to a frame
Frames are not encrypted at the application layer, and the reason is worth being straight about rather than implying more protection than exists. The protection is the private bucket, a credential whose reach is object storage and not the database, the organisation check above, and the short lived URL. There is no per organisation key, and per frame crypto shredding is not available today.Turning archiving off
An organisation can be taken out of frame archiving entirely, and can instead choose a finite retention window with a ceiling of 90 days. Both are set through the operational management path, not by you and not by an agent; ask if you want either. Two things about those settings:- Leaving the archive does not erase what is already in it. It stops new frames being written.
- A zero day window means the bytes are never written, not written and then cleaned up shortly after. At that setting the control plane records that a frame was captured and stores no image, so there is nothing waiting on a cleanup process to run on time.
Retention is decoupled from billing, permanently
Frame bytes do not participate in billing, usage or quota, and never have. The billing pipeline derives from the receipt ledger, which contains no frames. This is not a coincidence maintained by care. The two read and write completely disjoint paths, and that is checked directly: billing derived with frame data present and billing derived with it gone produce identical results. The consequence that matters to you: what happens to your frames can never cost you a billing record, so “we need it for billing” can never become an argument about images.What the control plane keeps besides the image
A frame’s identity is tracked separately from its bytes, and was long before the bytes were stored:- the frame id you can echo back as
observedFrame, - a per device sequence number,
- when it was registered, and the geometry it was captured at.
screenshot is not one of the actions
a receipt records, and the summaries that are recorded are deliberately thin: a
typed string is recorded as its length, never its content.